carry | Python ETL tool / Data migration | SQL Database library

You are confusing topics. The VM needs InotifyPropertyChanged events, which you have but are not using, to notify the Xaml in the front-end that a VMs property has changed and to bind to the new data reference.

This is needed for Lists or ObservableCollections. Once that is done, the ObservableCollection will then send notifications on changes to the list as items are added or removed.

Because you miss the first step:

The reason for the error is that you cannot assume that both prev and prev2 are not None. Your while condition only guarantees that at least one of them is not None, but not both. So that means you still need to have a None check inside the body of the loop.

There are also some other issues:

• l1==[0]: is not correct. The left side of this comparison is a linked list instance, while the right side is a standard list. These comparisons will always be False, and so you can just omit them

• You are adding the carry to the wrong sum. You should add the carry from the previous iteration to the current sum, so things are currently happing in the wrong order.

• The resulting list should be reversed. You can do this on the fly by prefixing each node to l3, instead of appending it. This will also make it unnecessary to create a dummy ListNode(0) before the final loop. You can just start with None.

• Your code mutates the original input lists. This will be acceptable on code challenge sites, and be efficient, but it is bad practice. The caller should not be unpleasantly surprised that the lists they provide as input have been reversed by a call to this addTwoNumbers function. You can solve this in several ways, but it is probably easiest to reverse them a second time to undo that operation.

• To avoid repetition of code, you should create a reverse function

I'll assume that the ListNode constructor can take a second argument for initialising its next reference:

loop through a 16 bit subtraction until the result is negative

"Branch" to Label if result is >0,

Do you see that these descriptions contradict each other?
The 1st one continues on 0, the 2nd one stops on 0.
Only you can decide which one is correct!

From a comment:

This code is part of a Bin to Ascii conversion, made by power of ten subtraction. The bin value could be >$8000, so it is 'negative' but this does not matter. In the first iteration I sub 10000 each cycle until the result is 'below 0', then I restore the previous value and continue with the remainder. The problem is how to detect the 'below 0' condition as said in the post

Next example subtracts 10000 ($2710) from the unsigned word stored at zero page address $90. The low byte is at $90, the high byte is at $91 (little endian).

There are a few ways to go about it. Personally I prefer to create accessors and mutators in the model - https://laravel.com/docs/8.x/eloquent-mutators . Not only does it keep the CrudController clean (so updateable) but it also allows you to save/load stuff from other forms (ex: user-facing forms).

split has this signature public String[] split(String regex). So you can index into the String[] like String name = inputStream[3] to retrieve some value. Then you could apply conditional logic like:

Is there generic practices and patterns to succesfully switch from dynamic to static memory allocation without breaking the code ?

No, not really. You'll have to rewrite all such code in pretty radical ways.

You have to realize why all safety-related and embedded systems ban malloc. The main reason is that it is non-deterministic. Instead of allowing completely variable sizes, you have to specify a maximum size for each such item, to cover the worst case scenario of the application.

Also, the presence of things like pointer-to-pointers instead of 2D arrays is a pretty certain indication that the original programmer didn't quite know what they were doing in the first place.

Additionally you need to drop the default types of C for stdint.h ones. That's standard practice in all embedded systems.

In general, I'd strongly advise to drop those "NASA rules" and implement MISRA-C instead. It's a way more professional and in-depth document. Some of the "NASA rules" simply don't make sense and the rest can be summarized as "No s***t Sherlock" beginner-level stuff which we were already told during our first beginner-level C programming class back in school. If these rules come as a surprise to someone, they shouldn't be writing mission-critical firmware in the first place.

You can create a custom JsonConverter that serializes your MyClass in the required format by making use of the metadata stored in Json.NET's own JsonObjectContract to get a list of all serializable properties and their attributes.

First, define the following converter and attribute:

You can't do this with objects directly as they are scoped by the VCL and can't "escape" it. As you've experienced, you need to load the labeled vcl first, so you also need to create the object in it.

But nothing prevents you from creating objects that reference a global variable so all objects have access to the same data.

Alternatively, you can use the Event function to use a PRIV_VCL (https://stackoverflow.com/a/60753085) also referencing a global pointer and avoid using objects completely. This is what is done here for example: https://github.com/varnish/varnish-modules/blob/master/src/vmod_vsthrottle.c#L345

TLDR: @overload is currently the only viable way to annotate some level of variance. PEP 646 -- Variadic Generics is a draft proposal to enable proper annotation of variadics.

The correct approach to annotate *args is to decide on some level of supported "variance length", and explicitly type this using @overload. Notably, explicit parameters must be positional only – they must be either __anonymous or positional, /. A final catch-all variadic @overload handles the case of more arguments.