promptly | Python Console Prompt Tools

This way you are adding many rows with one column each. Try .. VALUES ('${pg.country}', '${pg.region}', '${pg.site}'..., '${pg.compensation}')

is there a real good reason to do this, apart from maintaining a duplicate of branchB?

I don't think there is any good reason to waste time and effort in maintaining a duplicate branch. In a perfect world, you will have only one branch per one feature.
As a feature became bigger and bigger and code spreads in different files it became really hard to keep your changes in two different branches, and the most important thing is that you don't need to do it because at some point you want to merge everything to master.

will this duplicate situation potentially lead to conflicts ...

It really depends on how you keep the branchB up to date with changes from branchA, if you cherry-pick each commit, no, but if you move the changes in some different way, most likely you will have conflicts.

... and is it good practice?

I don't consider anything which makes your life harder a 'good practice'.
I think that every company has its own rules for 'good' and 'bad' practices, but in all of the companies, I have worked this is considered a bad one.

theoretically speaking, doesn't branchA now be an independent feature branch and... is it fair to call branchB a "zombie branch"?

It seems like branchA is an independent feature branch and branchB should be deleted as not needed and in order not to cause confusion.

I was overcomplicating things and figured out that the easiest way was to send the parallel url requests through multiple tasks in a Celery background worker (which I was using already). The Celery background worker uses Eventlet and multiple workers to handle a lot of concurrent tasks (especially with a lot of I/O wait time)

Using the code below I'm calling a Celery task twice with the same URL. Check every x millisecond if one of the requests is ready. If so, take the first finished request and cancel the other Celery task. The only limitation of this setup using Eventlet that Celery does not support terminating a task completely when it is running using Eventlet. In the future, I might want to improve this by using a key in Redis to let both parallel tasks check if the other one is finished. If that is true the remaining task can be canceled.

I think your issue is with the calculation of the size of the realloc. Rather than using sizeof(*newStructArray), shouldn't you really be using the size of your pointer type? I would have written this as realloc(*structArray, *maxDataSize * sizeof(struct Student *))

There's a lot of other stuff in here I would never do - passing all those variables in to checkArraySizeIncrease as pointers is generally a bad idea because it can mask the fact that things are getting changed, for instance.

Based on the errors and symptoms you described, it doesn't look like Cassandra is running.

It's likely that you're not using a supported Java version. You will need to switch to Java 8 with at least update 40 (but newer releases are recommended).

Have a look at the pre-requisites I documented in Installing Cassandra for details. Cheers!

how they would handle having to search for a user via their username?

How would you support this on a web site?

You would probably have a form; that form would have an input control that would allow the user to provide a user name. When the user submit the form, the browser would copy the form input controls into an application/x-www-form-urlencoded document (as described by the HTTP standard), then substitute that document as the query_part of the form action, and submit the query.

So the resulting request would perhaps look like

Yes.

(Emphasis mine)

Explanation

Indicates that the function does not return.

This attribute applies to the name of the function being declared in function declarations only. The behavior is undefined if the function with this attribute actually returns.

The first declaration of the function must specify this attribute if any declaration specifies it. If a function is declared with [[noreturn]] in one translation unit, and the same function is declared without [[noreturn]] in another translation unit, the program is ill-formed; no diagnostic required.

You can do away with the stack-based security by introducing a context object that provides access to the event.

But first, a few notes. I'm not going to speak to the merits of this design because that's subjective. However, I will address some terminology, naming, and design matters.

1. .NET's naming convention for events does not includethe "On" prefix. Rather, the method that raises the event (marked private or protected virtual, depending on whether you can inherit the class) has the "On" prefix. I've followed this convention in the code below.

2. The name "DelegateFactory" sounds like something that create delegates. This does not. It accepts a delegate and you're using it to perform an action within a retry loop. I'm having a tough time word-smithing this one, though; I've called the class Retryer and the method Execute in the code below. Do with that what you will.

3. DelegateWork/Execute return a bool but you never check it. It's unclear if that's an oversight in the example consumer code or a flaw in this thing's design. I'll leave it to you to decide, but because it follows the Try pattern to determine if the output parameter is valid, I'm leaving it there and using it.

4. Because you're talking about network-related actions, consider writing one or more overloads that accept an awaitable delegate (i.e. returns Task). Because you can't use ref or out parameters with async methods, you'll need to wrap the bool status value and the return value of the delegate in something, such as a custom class or a tuple. I will leave this as an exercise to the reader.

5. If an argument is null, make sure you throw ArgumentNullException and simply pass it the name of the argument (e.g. nameof(work)). Your code throws ArgumentException, which is less specific. Also, use the is keyword to ensure you're doing a reference equality test for null and not accidentally invoking overloaded equality operators. You'll see that in the code below, as well.

Introducing a Context Object

I'm going to use a partial class so that the context is clear in each snippet.

First, you have the events. Let's follow the .NET naming convention here because we want to introduce invoker methods. It's a static class (abstract and sealed) so those will be private. The reason for using invoker methods as a pattern is to make raising an event consistent. When a class can be inherited and an invoker method needs to be overridden, it has to call the base implemention to raise the event because the deriving class doesn't have access to the event's backing storage (that could be a field, as in this case, or perhaps the Events property in a Component-derived type where the key used on that collection is kept private). Although this class is uninheritable, it's nice to have a pattern you can stick to.

The concept of raising the event is going to go through a layer of semantic translation, since the code that registers the event handler may not be the same as the code that calls this method, and they could have different perspectives. The caller of this method wants to post a message. The event handler wants to know that a message has been received. Thus, posting a message (PostMessage) gets translated to notifying that a message has been received (OnMessageReceived).

First element in the returned array from text.split('●') is an empty string.