ipsec – Why does IKE have two phases?

The two phases part here is a bit of a separate matter to the rest. Those phases are just two parts of the handshake, and they’re just logical separations between the initial identity validation, authenticated key exchange, and parameter agreement (e.g. modes, features, etc.), which make up phase 1, and the derivation and setup of the secure channel used for bulk data transfer, which is done in phase 2.

This is very similar to how TLS in HTTPS works – the handshake initially exchanges information about the identities of the parties and what protocol version and features they supports, agrees on what features should be used, and (usually) does an initial key exchange which is authenticated by the long-term key from the certificate (as in IKE phase 1). It then uses that exchanged key to derive the necessary parameters for the secure channel that the bulk data is transferred over, and initiates that channel (as in IKE phase 2).

The duplication of security associations is because of certain usage requirements, partly due to historical hardware and telecommunications limitations.

The most commonly given example is in a distributed cellular network, whereby one client device might be talking to multiple cell towers. Each cell tower has plenty of processing power, is powered from the grid, and has a (relatively) high bandwidth network connection to the other towers. Compare that with your average late-90s cellular device, which has little processing power, runs on a small battery, has very limited bandwidth to the cell towers, and might be moving between towers quite a lot. Instead of making the phone perform a complete new two-way IKE handshake with every tower it comes across, there are instead two unidirectional channels – one for the client to talk to the tower, and another for the tower to talk back to the client – each with their own security parameters. The idea here is that the cellular device can broadcast data on one security association which is shared between all towers, allowing any tower to decrypt it, whereas data coming back from each tower to the cellular device has its own separate channel.

The differences in supported features, lifetimes, and renegotiations are precisely because of this difference in functionality. The outbound channel from the cellular device to the towers needs to be able to work in a broadcast environment, but the inbound channel does not. The security properties of each channel are tuned so that they are most effective for the specific use-case, providing the most security possible given the requirements of the system.

marketing – How to best handle pricing between MVP and Live phases?

We are planning to launch a new consumer web application with 7 core features and services. While putting together the release roadmap we figured our MVP can be very solid if we included 3 of the 7 core features and have subsequent releases for the rest of the services. Each additional release will probably take 6 weeks to develop and launch. So in total 6 months post MVP, we should be fully live.

From a user experience what would be best when it comes to pricing:

1- Should we show our live pricing from now and subscribe people to it?

2- Should we show our live pricing from now, but give a 25% discount for 6 months?

3- Should we show MVP (Beta) pricing and then change pricing when we are live? We can grandfather MVP users and keep them on the same pricing without increasing their price.

4- Any other ideas?

Any thoughts on this would be tremendously helpful.

How long are the life phases of a dragon?

The life phases of a dragon in 5th edition D&D are:

  • Egg
  • Wyrmling
  • Young
  • Adult
  • Ancient

Given that a dragon lives for at the least 15-ish centuries, up to I think well over two thousand years, how long does each phase of their life last?

Turn-based Pencil/paper game; phases – Game Development Stack Exchange

I’m not entirely sure this is the right place since all I see is coding questions, but I’ll ask anyway in the hopes that someone can answer or point me in the right direction.

I’ve been developing a pencil/paper war strategy game for a while now and have run multiple tests with other players, but I’ve been having one major issue with the action system.

The game is turn-based and phase-based during the turns. Each turn has 7 phases and each unit has anywhere between 1 and 7 phases, depending on the unit itself. The phases are split up for the turn phase, so a unit with a movement phase can only move on the x; |x|2|x|4|x|6|x|.

I have a separation of attack phases and movement phases which can be two different things. For example, a vehicle has a movement rating of 6 but an attack of 4. This means it can move 6 times and attack only 4 times but only on it’s designated rating.

Hopefully that’s enough explanation… Anyway, I have had an issue when it comes to initiative. If two units have an attack on the exact same part of the phase and both deal enough damage to destroy each other… How could I determine who attacked who first? Should one unit be able to destroy the other, or should both just destroy each other?

The second part of that would be… If both units still have the same attack phase and unit 1 deals enough damage to destroy the other but unit 2 only deals a small amount… Who went first? Should there be a dice roll or coin toss to determine or can someone help think of a way to fix this?

python: script to verify zero crossings to verify if the microphone phases are aligned

I have & # 39; n & # 39; microphones placed square and I want to make sure that all channels must be aligned in exactly the same time if the signal is equidistant from all microphones & # 39; n & # 39 ;, that is, in the center of the square.

I have written the following script to make the difference in zero crossing times for only two signals (wav file) and if the difference is above a certain precision, print that and rescue.

from scipy.io import wavfile
import numpy as np
import argparse

parser = argparse.ArgumentParser(description='diff the zero crossing of two files')
parser.add_argument('-f1', '--file_name_1', help='provide first file name')
parser.add_argument('-f2', '--file_name_2', help='provide second file name')
parser.add_argument('-p', '--precision', help='precision to compare against', type=float, default=0.0001)

args = parser.parse_args()
files = ()

sampling_rates = ()
signals = ()
for file in files:
  fs, signal = wavfile.read(file)
  signal = signal / max(abs(signal))                        # scale signal
  assert min(signal) >= -1 and max(signal) <= 1
  print 'fs           ==> ', fs, 'Hz'                       # sampling rate
  print 'len(signal)  ==> ', len(signal), 'samples'

sampsPerMilli = 0
#files should have same sampling rates and length
prev_rate = sampling_rates(0)
for rate in sampling_rates(1:):
  cur_rate =  rate
  sampsPerMilli = int(rate / 1000)
  if prev_rate != cur_rate:
    print("rates doesn't match %d %d"% (prev_rate, cur_rate))
  cur_rate = rate

#signal length also should be same
prev_length = len(signals(0))
for signal in signals(1:):
  cur_length = len(signal)
  if prev_length != cur_length:
    print("length of signals doesn't match for %d %d"% (prev_length, cur_length))
  cur_length = prev_length

zccs = ()
for signal in signals:
  zcc = ()
  DC = np.mean(signal)
  newSignal = signal - DC
  for i in range(1, int(len(newSignal))):
    if((newSignal(i) * newSignal(i-1)) < 0):
      #print("crossing at %f seconds"% ((i/sampsPerMilli) * 0.001))
      zcc.append((i/sampsPerMilli) * 0.001)

for a, b in zip(zccs, zccs(1:)):
  if len(a) != len(b):
    print("length doesn't match %d %d"% (len(a), len(b)))
    for c, d in zip(a, b):
      if c-d > args.precision:
        print("precision %f c %f d %f exceeded"% (args.precision, c, d))

Is there a better approach or can this script be improved?

Sharepoint online: how can I create a list form with multiple approval phases?

I want to create an online sharepoint list form that would have multiple approval phases (4 to be precise). Suppose phase 1 (or part 1) of the form is completed, then the user is supposed to wait for approval. Once approved, you must be eligible to complete phase 2 of the form, etc.

In general, my goal is to create a list form with multiple phases. Is it possible to achieve this or something similar in online sharepoint? If so, how?

Reference request: Where were the ideas of voting, accepting and compromising the phases originally introduced?

In the SCP of the Stellar Consensus Protocol, the voting procedure follows a 3-phase commitment, that is, voting, accepting and confirming, that is, see section 5.

Is it a novel introduction or has it been introduced before? If yes, where? More specifically, I refer to the definitions of these given in section 5.

Planning of research projects: time estimates for various research methods and phases

Overcoming obstacles

There seems to be no consensus on this, as it can vary greatly due to
to project parameters and the unique needs and constraints at the moment
of execution.

I think it is necessary to address it by looking at the factors (or context) that affect the amount of time required, which is probably easier to document compared to trying to find the "magic" number. But in general, you can try to divide it into the types of methods, the type of end user (or demographic data), the nature of the information you want to collect. That should be relatively consistent enough between different researchers.

Of course, sometimes the chosen method is dictated by the constraints of the project (for example, time, budget, available resources, etc.) so it is possible that it does not even get a real reflection of the amount of real time needed, since that is only getting a measure of the amount of time allotted.

I know that with qualitative research, time is very difficult
estimate from "information saturation" (inflection point where there are no new
Insights are discovered) is a stranger.

Again, you can probably see this in terms of the importance (how valid the finding is) and the trust (how applicable this is to the rest of the users) that the researcher wants to achieve with the research, which is more objective than just trying. to estimate the point at which the saturation of information is reached. When you combine this with the type of information you want to discover (for example, critical usability problems versus minor problems), you can arrive at a rough estimate.

For example, it is often cited that it is not necessary to test a large number of users to discover a critical usability problem, since it is likely that something very important will affect any user that chooses to perform the tests. While something more subtle will take many more users for the researcher to determine the exact cause of the behavior.

Methods versus phases

I think that if you can get an approximate figure in the methods, then it is a question of applying a factor in the phases, since they will depend on the chosen method. For example, if you want to do most of the research manually (that is, pencil and paper in person), the analysis will take more time. Sorting cards on physical cards is fine as long as you are not handling hundreds of cards on many different walls because the processing and analysis time does not fit very well.

What is the purpose of the estimates?

I think that if the ultimate goal is for you to have a resource that gives you a good estimate of the effort required for research activities, it is better to compile your own data, since at least many of the variations caused by factors that affect The accuracy and precision of the estimates will be reduced.

But I think if you ask the same question to the developers, they will also have difficulty finding an accurate answer. Basically, the estimate will only be as accurate as the parameters used to produce the estimate, so the estimate of the time to correct an error compared to the time required to implement a function using a given API and based on an existing code will give different degrees of accuracy (and this can also vary between individuals).

Agile UX?

It's great that I'm researching in this area, and this is the exact kind of problem that agile methodologies are supposed to help with. When it comes to managing projects that can change during the useful life of the product or service you want. develop. Therefore, my advice is to be as accurate as I can reasonably expect someone to do it and then adjust those baselines as it goes.

Design patterns – How to calculate general progress in independent phases?

The usual way to do this is to determine how many units of work will be done, and then the API will return the completed number or the completed percentage of the total. For something like a download manager, the number of units of work would be the sum of the number of bytes of all the files selected to download, for example, or possibly only the total number of files to download. (Both are reasonable elements to use in the unit of work, but with only the number of files, one file can have 100 bytes and another 100 GB, which means that users of your API will not get the best information from your API in that case).)

In your case, you have the option of dividing it into phases (there seems to be a collection phase and a processing phase, at least, maybe more?), Where each phase is a unit of work. Do you have any way of knowing how many things will be collected in the collection phase? If so, you could add up the amount of things that should be collected and know how many units of work are done during the collection phase. (In the same way, each of them must be processed presumably, so that you know how many work units are in the processing phase, etc.) If not, you must leave the phase as a complete unit or use an indeterminate progress indicator . of some kind.

One thing you would avoid is to add more units of work after you have already told a client how many units of work there will be. It's very confusing for users (and no doubt developers who use their API) when a progress bar goes back as time goes by instead of monotonously progressing.