Repercussion | A game created for Ludum Dare | Game Engine library

/(?=TITLE: )/g seems like a reasonable start. I'm not sure if the gutter of 2 characters whitespace is in your original text or not, but adding ^ or ^ to the front of the lookahead is nice to better avoid false-positives, i.e. /(?=^TITLE: )/mg, /(?=^ TITLE: )/mg or /(?=^ *TITLE: )/mg.

The overall rule here is this: "If a callback is EVER called asynchronously through any code path, then it should always be called asynchronously, even if the result or error is known synchronously."

This is because you NEVER want an API that sometimes calls its callback synchronously and sometimes asynchronous. That makes it very easy for the caller to end up with hard to find and reproduce bugs that only surface when the API itself sometimes calls things synchronously or sometimes calls them asynchronously or sometimes call it one way the first time and then another way the second time.

Here's an example I've seen in the nodejs streams code. There is an API in the streams code that accepts an asynchronous callback. But, as the API starts to process things, it finds that it already has in its buffer the required data to satisfy the API request. It could call the callback synchronously because it already has the data. But, other times, it will have to read data from the disk before calling the callback and thus the callback will be called asynchronously. In the streams code, when it encounters this case where it already synchronously has the data, it still queues the callback to be called on the nextTick because it needs to consistently only return the data asynchronously.

Similarly, sometimes, as part of the setup code for a particular stream API, it encounters an error and that error is known synchronously. Again, it only calls the callback with the error on a nextTick so that it is again being consistent and always calling the callback asynchronously.

But, don't take this too far as this does not mean that every single callback should only ever be called asynchronously on a future tick. It's perfectly OK to have a callback that is always called synchronously as long as the API explains that and the caller expects that. Heck, all the array iteration functions like .map() or .filter() do exactly that and work just fine for what they do and they are massively simpler to use because of their synchronous nature.

In the context of your specific code you show, doing:

• Those are not the brokers, but the different zookeeper servers that form the zookeeper ensemble for your Kafka cluster.

• You can use just one of them, but that implies the specific zookeeper must be running in order for the command to succeed.

• You should use all of them in order to achieve high-avaliability and fault-tolerance at the start of your clients, avoiding the scenario in which the zookeeper you just set on your configs is stopped (while the others are still running).

  Setting all of them guarantees (if the quorum is healthy) that your kafka command will be successful even if some of the zookeeper servers are not alive.

Zookeeper Multi Server Setup

For reliable ZooKeeper service, you should deploy ZooKeeper in a cluster known as an ensemble. As long as a majority of the ensemble are up, the service will be available. Because Zookeeper requires a majority, it is best to use an odd number of machines. For example, with four machines ZooKeeper can only handle the failure of a single machine; if two machines fail, the remaining two machines do not constitute a majority. However, with five machines ZooKeeper can handle the failure of two machines.

Since users appears to be a single "chunk" of state, an array containing objects with both an age and name property, then the parent component would need to hold the state. Make a single API/asynchronous call from the parent to update any state.

You can "map"/"filter" the state into two arrays to be passed as props to the child components. This can be done "on-the-fly" as you pass the prop. When the parent's state updates the children will be passed the latest state values.

From what you describe you really don't need to convert to CGImage at all. You can do all processing within a Core Image + Vision pipeline:

1. Create a CIImage from the camera's pixel buffer with CIImage(cvPixelBuffer:).
2. Apply filters to the CIImage.
3. Use a CIContext to render the filtered image into a new CVPixelBuffer. For best performance use a CVPixelBufferPool for creating those target pixel buffers.
4. Pass the pixel buffer to Vision for analysis.
5. If Vision decides to keep the image, use the same CIContext to render the pixel buffer (wrap it into a CIImage again like in 1.) into a target format of your choice, for instance with context.writeHEIFRepresentation(of:...).

Only in the end will the image data be transferred to the CPU side.

As it is written here:

With the introduction of Azure DevOps Services, organizational resources and APIs are now accessible via either of the following URLs:

• https://dev.azure.com/{organization} (new)
• https://{organization}.visualstudio.com (legacy)

Regardless of when the organization was created, users, tools, and integrations can interact with organization-level REST APIs using either URL. As the developer of an extension, integration, or tool that interacts with Azure DevOps Services, it is important to understand how to properly work with URLs made available to your code and how to properly form URLs when calling REST APIs.

Both links give you the same so you should not get any repercussions.

Ultimately it comes down to a decision that's informed by your particular business/product with regards to how long you want to keep deleted entities in your system. For some applications it's important to always keep a history of deleted things or even individual revisions to records stored as a kind of ledger or history. You'll have to make a judgement call as to how long you want to keep your deleted entities.

I'd recommend that you also add a deleted_at column if you haven't already and then you could easily leverage something like Hasura's new Scheduled Triggers functionality to run a recurring job that fully deletes records older than whatever your threshold is.

You could also leverage Hasura's permissions system to ensure that rows that have been deleted aren't returned to the client. There is documentation and examples for ways to work with soft deletes and Hasura

For your second question it is definitely much faster to check for the deleted flag on records than to have to try and diff the entire dataset looking for things that are now missing.

Theoretically, yes. You should be able to just go ahead and try again. It might mean that some of the cleanup hasn't been performed yet, so there are some partial tables floating around, taking up memory, but nothing that should impact your data quality.

Is this a proper workflow?

That depends on what you want to achieve. There are many possible workflows.

Is there any repercussions to deleting the branch in step 10 (i.e. does it orphan newfeature?)?

Branches are just pointers to a commit, they do not depend on each other. Deleting a branch removing that entry point to the graph, but it does not remove the commits by itself. As long as you have a way to go back to that commit from another branch, the commits will never be removed.