building a robust Chrome extension that effortlessly captures full-page screenshots, providing users with a seamless and enhanced browsing experience.

multi-tenant data in Amazon S3 requires you to think about how tenant data will be distributed across buckets and keys without undermining the security, manageability, and performance of your SaaS solution.

If your application runs on-premises, or on another cloud provider, you can use workload identity federation to grant access to external identities without using a service account key. Some client libraries can use Application Default Credentials (ADC) to automatically generate credentials for external identities. To learn more, see Configuring workload identity federation.

Since it can only load and store numbers, it needs to call out to JavaScript code to do anything interesting (create DOM nodes, make network connections, etc.). WebAssembly code is still inside the browser sandbox and can only use the browser APIs that JavaScript has access to.

asm.js subset is basically JavaScript where you can only use numbers (no strings, objects, etc.). This is all you need to run C++ code since everything in C++ is either a number or a pointer to a number, and pointers are also numbers. The C++ address space is just a giant JavaScript array of numbers and pointers are just indices into that array.

Because our product is written in C++, which can easily be compiled into WebAssembly, Figma is a perfect demonstration of this new format’s power.

Ergonomics experts recommend good lighting to reduce eye strain and avoid craning your neck at an unnatural angle. An abundance of natural lighting in your workspace is ideal because it can boost your sense of well-being and energy while reducing eye strain—daylight and access to outdoor views give your eyes opportunities to relax and recover from the strain of staring at a monitor all day.

describe a WebSocket in the same way that a regular HTTP endpoint is described, with a request/response message schema, but unlike a regular HTTP endpoint, on a WebSocket there will be zero to many instances of the request/response messages sent in each direction. From a spec perspective, this could be indicated by simply adding a flag to say that the request and/or response messages are streamed. Further information could be added to indicate what streaming protocol should be used (websockets, SSE, newline separated JSON ala Twitter streaming endpoint style).

any data that was loaded from another origin without CORS approval, the canvas becomes tainted. A tainted canvas is one which is no longer considered secure, and any attempts to retrieve image data back from the canvas will cause an exception to be thrown.

text resize to fit its parent container, but it's been largely limited to adjusting the font size. The problem with this approach is that making the font smaller is not always the best option for our designs.With variable fonts that contain a width axis, we can adjust the font-stretch property with CSS to condense the font. When we combine this with font-size as well we can create more flexible response text on the web.

In all cases, the technique is appropriate for structures with high degree (large fanout). For low-degree structures, outline editors or graph viewers are more effective.

fundamental unit of functionality will just be large.

"Lifting State Up" is legitimately the answer to the state management problem in React and it's a rock solid one.

state more logically separated and located in the react tree closer to where it matters.

Sure you can hook up different reducers to manage different parts of your application, but the indirection of going through all these action creators and reducers is not optimal.

consistently see developers putting all of their state into redux. Not just global application state, but local state as well. This leads to a lot of problems

One of the reasons redux was so successful was the fact that react-redux solved the prop drilling problem. The fact that you could share data across different parts of your tree by simply passing your component into some magical connect function was wonderful.

CreatePagesArgs

Bootstrap sequence

When you’re writing tests for a very specific feature, you should use your UI to test it. But when you’re testing another area of the system that relies on a state from a previous feature: do not use your UI to set up this state.

If your company does offer you more equity, make sure you ask whether the 409A (or fair market value) of the company is being updated. With revised forecasts given the COVID-19 situation, it may be possible for your company to issue your stock at a lower strike price if the company revalues its 409A.

inline editable UI involve showing errors. You should account for this when thinking about UX. You may also have difficulty achieving the level of accessibility necessary to support mouse events. Touch events will likely also be an issue. Finally, supporting mobile devices can be hard when you have form elements hidden. This will be especially tricky if the UI has to support a mobile layout, because there is no hover to show users whether the field is editable inline on touch screens.

eventual consistency, SWR will automatically revalidate the data from the origin as soon as data is rendered from the cache.

code exchange with Auth0 and retrieve the user's id_token and access_token which will be stored in memory.

Apollo client, help with handling errors, but not as easily as in a REST API

not recommended because it adds more complexity because of things such as: Types Queries Mutators Resolvers High-order components

functional programming utility, and is included in Redux as a convenience. You might want to use it to apply several store enhancers in a row.

speeds up the loading of your application and reduces the payload size of your application.

privacy and preventing governments from using the system to compile data on citizens was a primary goal

The shortcut to run the last plugin in Figma is ⌥ ⌘ + P. Alternatively you can use ⌘+/to bring up the global command menu and type the name of the plugin.

less easy when you switch from JavaScript to TypeScript. Running TypeScript on Cloud Functions requires a compilation phase to convert the TypeScript into JavaScript so that it can be executed by the emulator. It adds a bit of a hassle

Promises and useEffect(async () => ...) are not supported, but you can call an async function inside an effect.. That's why using async directly in the useEffect function isn't allowed.

browser behavior of automatically attaching any cookies bounded to https://examplebank.com for any HTTP calls to that domain, including AJAX calls from https://evilunicorns.com to https://examplebank.com

Without same-origin policy, that hacker website could make authenticated malicious AJAX calls to https://examplebank.com/api to POST /withdraw even though the hacker website doesn’t have direct access to the bank’s cookies.

pitfalls with PurgeCSS, like it won't actually render your components to check dynamic class usage, so you want to avoid partial class names in dynamic renders and instead stick to full class names

PurgeCSS which will parse any files that match the given file globs for the usage of the selectors in your CSS. If a selector isn't present in any of the matched files, then it rips those styles out of the CSS, ultimately slimming the build.

central service registry

minimizing latency and enabling event-driven interactions with applications.

commonly used libraries and SDKs can be moved to a dedicated service that can be managed independently, making the service immutable.

Often our efforts don’t “immediately translate into desired organizational outcomes.” In other words, “you could be doing all the right things but, unfortunately, it’s taking a long time for it to lead to positive results.”

It’s normal to underperform on occasion. After all, everyone has an off quarter — or even an off year — from time to time.

When a React component dispatches actions, how can another service catch the actions, accumulate and group them, then redispatch a single action?

“undefined as a value” and “undefined as a type” are both written as undefined. Depending on where you use it, it is interpreted as a value or as a type. The same is true for null.

Tuple types allow you to express an array where the type of a fixed number of elements is known

Currying is the process of transforming a function that takes multiple arguments into a series of functions that take one argument at a time

They are strangers in the room and I don’t even recall their names, so how can I begin to trust them? The answer is damn simple: start writing tests from day 1!

Senior Developer or Tech Lead, or Software Architect, then you probably recall that your career path had multiple rounds of specializing on different technologies and tools within one domain.

additional layers of complexity and dependency on many third party providers

Jupytext can be configured to automatically pair a git-friendly file for input data while preserving the output data in the .ipynb file

different problems that are sufficiently similar that you can apply a same model to them, but sufficiently different that this model has to be customized considerably to be applicable in each case.

In your Python interpreter, enter import this and you will see "The Zen of Python". Python generally encourages code to be written in the most obvious way possible. Ideally, all code should be written in one way - the community doesn't think it should be in a Functional style.

He discussed the history of Functional Programming language features in one of his blog posts. As a result, the language implementations have not been optimized for Functional Programming features.

Every map and filter expression can be expressed as a list comprehension.

Ever had a bug where you wondered how a variable you set to 25 became None? If that variable was immutable, the error would have been thrown where the variable was being changed, not where the changed value already affected the software - the root cause of the bug can be found earlier.

Every useState() call gets its own “memory cell”.

point of supporting multiple useState() calls is so that you can extract parts of stateful logic (state + effects) out of your components into custom Hooks which can also independently use local state and effects

array destructuring syntax to name useState() state variables but these names are not passed to React. Instead, in this example React treats name as “the first state variable”, surname as “the second state variable”, and so on. Their call index is what gives them a stable identity between re-renders

Unless blank=False is set on the field along with a default then a label containing "---------" will be rendered with the select box.

The foundation of GraphQL is its type system. There are basic types like String and Integer and there are complex types that have named attributes.

Dependency Injection, in its basic form of passing functions into components, keeps things testable, and visualizable in tools like Storybook.

make stylable all of the visual states of your application - no clicking around required - just jump right to the state

The easy, functional-programming concept that a component can receive both functions AND data as arguments

in React, the component doesn't encapsulate completely around the lookup method. It provides a default implementation but allows its environment to override it

What happens when multiple components in the same app want the same data? With the current implementation, each component would have to refetch data from the server. We will try to improve our implementation to handle caching and concurrent access to the same asynchronous data store.

if you’re building for both browsers and Node.js since you’ll have to bundle a build for browsers as well

One of the more confrontational parts of JavaScript development has always been its module system

What once began as a humble side project on Reddit, which you can see here, has now grown so much that it has fundamentally transformed how we build and develop Node.js applications.

whenever there's a lot going on, computers (but mostly humans) will get stuff wrong. In the 6 lines of our component, rendering 2 node types, we change syntaxes from JS to JSX, and back, 8 times! Count them - it's like JS(JSX(JS(JSX(JS))))! This is not the simplest code we can write.

REST_FRAMEWORK = { 'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination', 'PAGE_SIZE': 100 }

define an object inside your React function component, it is not going to be referentially equal to the last time that same object was defined (even if it has all the same properties with all the same values)