How is Sandboxing implemented?

Question: What is sandboxing? Is it the trapping of OS system calls and then deciding whether to allow it to pass through or not?
How is it implemented to begin with? Would it be by way of hooks in the SSDT (kernel level)?
Answer: Well this answer ended up fairly long, but sandboxing is a huge topic. At its most basic, sandboxing is a technique to minimize the effect a program will have on the rest of the systems in the case of malice or malfunction. This can be for testing or for enhancing the security of a system. The reason one might want to use a sandbox also varies, and in some cases it is not even related to security, for example in the case of OpenBSD's systrace. The main uses of a sandbox are:

Program testing to detect broken packages, especially during builds.
Malware analysis to understand behavior of malicious software.
Securing untrusted or unsafe applications to minimize damage they can do.

There are many sandboxing techniques, all with differing threat models. Some may just reduce attack surface area by limiting APIs that can be used, while others define access controls using formalized models similar to Bell-LaPadula or Biba. I'll be describing a few popular sandboxing techniques, mostly for Linux, but I will also touch on other operating systems.
Seccomp
Seccomp is a Linux security feature that reduces kernel attack surface area. It is technically a syscall filter and not a sandbox, but is often used to augment sandboxes. There are two types of seccomp filters, called mode 1 (strict mode) and mode 2 (BPF mode).
Mode 1
Seccomp mode 1 is the most strict, and original, mode. When a program enables mode 1 seccomp, it is limited to using only four hardcoded syscalls: read(), write(), exit(), and rt_sigreturn(). Any file descriptors that will be needed must be created before enforcing seccomp. In the case of a violation, the offending process is terminated with SIGKILL.
Taken from another answer I wrote on another StackExchange site, a sample program that securely executes a function that returns 42 in bytecode:
#include <unistd.h>
#include <stdint.h>
#include <stdio.h>
#include <sys/prctl.h>
#include <sys/syscall.h>
#include <linux/seccomp.h>

/* "mov al,42; ret" aka "return 42" */
static const unsigned char code[] = "\xb0\x2a\xc3";

int main(void)
{
    int fd[2], ret;

    /* spawn child process, connected by a pipe */
    pipe(fd);
    if (fork() == 0) {
        close(fd[0]);

        /* enter mode 1 seccomp and execute untrusted bytecode */
        prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT);
        ret = (*(uint8_t(*)())code)();

        /* send result over pipe, and exit */
        write(fd[1], &ret, sizeof(ret));
        syscall(SYS_exit, 0);
    } else {
        close(fd[1]);

        /* read the result from the pipe, and print it */
        read(fd[0], &ret, sizeof(ret));
        printf("untrusted bytecode returned %d\n", ret);
        return 0;
    }
}

Mode 2
Mode 2 seccomp, also called seccomp-bpf, involves a userspace-created policy being sent to the kernel, defining which syscalls are permitted, what arguments are allowed for those syscalls, and what action should be taken in the case of a syscall violation. The filter comes in the form of BPF bytecode, a special type instruction set that is interpreted in the kernel and used to implement filters. This is used in the Chrome/Chromium and OpenSSH sandbox on Linux, for example.
A simple program that prints the current PID using seccomp-bpf:
#include <seccomp.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

int main(void)
{
    /* initialize the libseccomp context */
    scmp_filter_ctx ctx = seccomp_init(SCMP_ACT_KILL);

    /* allow exiting */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(exit_group), 0);

    /* allow getting the current pid */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(getpid), 0);

    /* allow changing data segment size, as required by glibc */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(brk), 0);

    /* allow writing up to 512 bytes to fd 1 */
    seccomp_rule_add(ctx, SCMP_ACT_ALLOW, SCMP_SYS(write), 2,
        SCMP_A0(SCMP_CMP_EQ, 1),
        SCMP_A2(SCMP_CMP_LE, 512));

    /* if writing to any other fd, return -EBADF */
    seccomp_rule_add(ctx, SCMP_ACT_ERRNO(EBADF), SCMP_SYS(write), 1,
        SCMP_A0(SCMP_CMP_NE, 1));

    /* load and enforce the filters */
    seccomp_load(ctx);
    seccomp_release(ctx);

    printf("this process is %d\n", getpid());
    return 0;
}

Because the Linux syscall ABI keeps arguments in general purpose registers, only these registers are validated by seccomp. This is fine in some cases, such as when an argument is a bitwise ORed list of flags, but in cases where the argument is a pointer to memory, filtering will not work. The reason for this is that the pointer only references memory, so validating the pointer only ensure that the pointer itself is allowed, not that the memory it is referencing has not been changed. This means that it is not possible to reliably filter certain arguments for syscalls like open() (where the path is a pointer to a null-terminated string in memory) without careful analysis and extensively limiting memory-related syscalls. To filter paths and similar objects, mandatory access controls or another LSM-based framework must be used.
Pledge
OpenBSD has added a syscall filter similar to (but more coarse-grained than) seccomp called pledge (previously tame). Pledge is a syscall that applications can opt into, essentially "pledging" that they will limit their uses of various kernel interfaces. No matter how much the application begs, the kernel won't revoke the restrictions once they are in place, even if it changes its mind.
Pledge allows an application to make a promise, which is a group of actions which will be permitted, with all others being denied. In essence, it is promising to only use functions it explicitly requests beforehand. Some (non-exhaustive) examples:

The stdio promise allows basic functionality like closing file descriptors or managing memory.
The rpath promise allows syscalls that can be used to read the filesystem.
The wpath promise allows syscalls that can be used to write to the filesystem.
The tmppath promise allows syscalls that can read/write, but only in /tmp.
The id promise allows syscalls that are used to change credentials, like setuid().

Although pledge is much more coarse-grained than seccomp, it is, for this reason, much easier to use and maintain. Because of this, OpenBSD has progressed to adding pledge support to a wide variety of their base applications, from things as security-sensitive as sshd to things as trivial as cat. This "security by default" architecture ends up greatly improving the security of the system as a whole, even if individual promises are coarse-grained and not particularly flexible.
Chroot
A chroot is a *nix feature that allows setting a new path as the root directory for a given program, forcing it to see everything as relative to that path. This is not usually used for security, since a privileged program can often escape a chroot, and because it does not isolate IPC or networking, allowing even unprivileged processes to do mischief like killing other processes. In a touch, it can be used to augment other security techniques. It is very useful for preventing an application from doing accidental damage, and for giving legacy software a view of the filesystem that it expects.
Chrooting bash, for example, would involve putting any executables and libraries it needs into the new directory, and running the chroot utility (which itself just calls the syscall of the same name):
host ~ # ldd /bin/bash
        linux-vdso.so.1 (0x0000036b3fb5a000)
        libreadline.so.6 => /lib64/libreadline.so.6 (0x0000036b3f6e5000)
        libncurses.so.6 => /lib64/libncurses.so.6 (0x0000036b3f47e000)
        libc.so.6 => /lib64/libc.so.6 (0x0000036b3f0bc000)
        /lib64/ld-linux-x86-64.so.2 (0x0000036b3f938000)
host ~ # ldd /bin/ls
        linux-vdso.so.1 (0x000003a093481000)
        libc.so.6 => /lib64/libc.so.6 (0x000003a092e9d000)
        /lib64/ld-linux-x86-64.so.2 (0x000003a09325f000)
host ~ # mkdir -p newroot/{lib64,bin}
host ~ # cp -aL /lib64/{libreadline,libncurses,libc}.so.6 newroot/lib64
host ~ # cp -aL /lib64/ld-linux-x86-64.so.2 newroot/lib64
host ~ # cp -a /bin/{bash,ls} newroot/bin
host ~ # pwd
/root
host ~ # chroot newroot /bin/bash
bash-4.3# pwd
/
bash-4.3# ls
bin  lib64
bash-4.3# ls /bin
bash  ls
bash-4.3# id
bash: id: command not found

Only a process with the CAP_SYS_CHROOT capability is able to enter a chroot. This is necessary to prevent a malicious program from creating its own copy of /etc/passwd in a directory it controls, and chrooting into it with a setuid program like su, tricking the binary into giving them root.
Namespaces
On Linux, namespaces are used to isolate system resources, giving a namespaced program a different understanding of what resources it owns. This is commonly used to implement containers. From the namespaces(7) manpage:

A namespace wraps a global system resource in an abstraction that makes
it appear to the process within the namespace that they have their
own isolated instance of a global resource.  Changes to the global
resource are visible to other processes that are members of the
namespace, but are invisible to other processes.

There are 7 namespaces supported under Linux currently:

cgroup - Cgroup root directory
IPC - System V IPC and POSIX message queues
Network - Network interfaces, stacks, ports, etc
Mount - Mountpoints, similar in function to a chroot
PID - Process IDs
User - User and group IDs
UTS - Hostname and domain name

An example of PID namespaces using the unshare utility:
host ~ # echo $$
25688
host ~ # unshare --fork --pid
host ~ # echo $$
1
host ~ # logout
host ~ # echo $$
25688

While these can be used to augment sandboxing or even be used as an integral part of a sandbox, some of them can reduce security. User namespaces, when unprivileged (the default), expose a much greater attack surface area from the kernel. Many kernel vulnerabilities are exploitable by unprivileged processes when the user namespace is enabled. On some kernels, you can disable unprivileged user namespaces by setting kernel.unprivileged_userns_clone to 0, or, if that specific sysctl is not available on your system, setting user.max_user_namespaces to 0. If you are building your own kernel, you can set CONFIG_USER_NS=n to disable user namespaces globally.
Mandatory Access Controls
A MAC is a framework for defining what a program can and cannot do, on a whitelist basis. A program is represented as a subject. Anything the program wants to act on, such as a file, path, network interface, or port is represented as an object. The rules for accessing the object are called the permission, or flag. Take the AppArmor policy for the ping utility, with added comments:
#include <tunables/global>

/bin/ping {
  # use header files containing more rules
  #include <abstractions/base>
  #include <abstractions/consoles>
  #include <abstractions/nameservice>

  capability net_raw,  # allow having CAP_NET_RAW
  capability setuid,   # allow being setuid
  network inet raw,    # allow creating raw sockets

  /bin/ping mixr,      # allow mmaping, executing, and reading
  /etc/modules.conf r, # allow reading
}

With this policy in place, the ping utility, if compromised, cannot read from your home directory, execute a shell, write new files, etc. This kind of sandboxing is used for securing a server or workstation. Other than AppArmor, some popular MACs include SELinux, TOMOYO, and SMACK. These are typically implemented in the kernel as a Linux Security Module, or LSM. This is a subsystem under Linux that provides modules with hooks for various actions (like changing credentials and accessing objects) so they can enforce a security policy.
Hypervisors
A hypervisor is virtualization software. It usually leverages hardware features that allow isolating all system resources, such as CPU cores, memory, hardware, etc. A virtualized system believes not just that it has root, but that it has ring 0 (kernelmode). Hardware is either abstracted by the CPU (the case for the CPU cores and memory itself), or emulated by the hypervisor software (for more complex hardware, such as NICs). Because the guest is made to believe it owns the whole system, anything that can run on that architecture will tend to also run in the virtual machine, allowing a Linux host with a Windows guest, or a FreeBSD host with a Solaris guest. In theory, a hypervisor will prevent any actions in the guest from affecting the host.
A useful resource that helps with a low-level understanding how a guest is set up is an LWN writeup on the KVM API. KVM is a kernel interface supported on Linux and Illumos (a family of open source forks of Solaris) for setting up virtual machines. As it's fairly low level (interaction only being through IOCTLs on a file descriptor opened against the /dev/kvm character device), it is typically the backend for projects like QEMU. KVM itself makes use of privileged hardware virtualization features such as VT-x on Intel processors and AMD-V on AMD.
It's common for hypervisors, such as with the popular Cuckoo sandbox, to be used to assist in malware analysis. It creates a virtual machine that malware can be run on, and it analyzes the internal state of the system, reading memory contents, dumping memory, etc. Because it runs a full operating system, it is often more difficult for malware to realize it is running virtualized. Common techniques like attaching a dummy debugger to itself so it cannot be debugged can be fooled, though some malware can attempt to detect virtualization (with varying levels of sophistication). Hypervisor detection itself is a very broad and complex subject.
Hypervisors are often (ab)used for security, such as by Qubes OS or Bromium (using the Xen hypervisor to isolate Fedora and Windows, respectively). Whether or not this is a good idea is often debated, due to bugs in Xen cropping up repeatedly. A famous and rather abrasive quote from Theo de Raddt, founder of OpenBSD, on the topic of virtualization when relied on for security:

You are absolutely deluded, if not stupid, if you think that a worldwide collection of software engineers who can't write operating systems or applications without security holes, can then turn around and suddenly write virtualization layers without security holes.

Whether or not a hypervisor is a good choice for security depends on many factors. It is typically easier to use and maintain, since it isolates an entire guest operating system, but it has a large attack surface area and does not provide fine-grained protections.
Containers
Containers are similar to hypervisors, but rather than using virtualization, they use namespaces. Each container has every resource put in its own namespace, allowing every container to run an independent operating system. The init process on the container sees itself as PID 1 running as root, but the host sees it as just another non-init and non-root PID. However, as they share the host's kernel, they can only run the same type of operating system as the host. Additionally, while containers can have root processes that can do privileged actions like setting up network interfaces (only in that container's namespace, of course), they cannot change global kernel settings that would affect all containers. Docker and OpenVZ are popular container implementations.
Because containers fundamentally rely on user namespaces of various implementations (standard Linux namespaces for Docker, and a bespoke namespace technology for OpenVZ), they are often criticized for providing poor security. Container escapes and privilege escalation vulnerabilities are not uncommon on these systems. The reason for these security issues stems from the fact that the namespace root user can interact with the kernel in new and unexpected ways. While the kernel is designed not to let the namespace root user make any obviously dangerous changes to the system that cannot be kept in a namespace (like sysctl tweaks), the root is still able to interact with a lot more of the kernel than an unprivileged process. Because of this, a vulnerability that can only be exploited by root in the process of setting up a virtual network interface, for example, could be exploited by an unprivileged process if that process is able to enter a user namespace. This is an issue even if the syscalls can only "see" the network interface of the container.
In the end, a user namespace simply allows an unprivileged user to interact with far more of the kernel. The surface area is increased to such an extent that many vulnerabilities that otherwise would be relatively harmless instead become LPEs. This is what happens when kernel developers tend not to keep a security mentality when writing code that only root can interact with.
Other technologies
Linux is certainly not the only operating system that has sandboxing. Many other operating systems have their own technology, implemented in various different ways and with varying threat models:

AppContainer on Windows provides isolation similar to a combination of chroots and namespaces. Domains, files, networks, and even windows are isolated.

Seatbelt on OSX acts as mandatory access controls, limiting the resources a confined application can access. It has seen its share of bypasses.

Jails on FreeBSD build on the concept of chroot. It assigns an IP address to the program running in the jail and gives it its own hostname. Unlike a chroot, it is designed for security.

Zones on Solaris are advanced containers that run a copy of Solaris' userland under the host's kernel. They are similar to FreeBSD Jails, but more feature-rich.
Answer: A quick look at Wikipedia page about sandboxing:

In computer security, a sandbox is a security mechanism for separating
  running programs, usually in an effort to mitigate system failures or
  software vulnerabilities from spreading. It is often used to execute
  untested or untrusted programs or code, possibly from unverified or
  untrusted third parties, suppliers, users or websites, without risking
  harm to the host machine or operating system. A sandbox typically
  provides a tightly controlled set of resources for guest programs to
  run in, such as scratch space on disk and memory. Network access, the
  ability to inspect the host system or read from input devices are
  usually disallowed or heavily restricted.
In the sense of providing a highly controlled environment, sandboxes
  may be seen as a specific example of virtualization. Sandboxing is
  frequently used to test unverified programs that may contain a virus
  or other malicious code, without allowing the software to harm the
  host device.

So, sandbox is an implementation that creates a controlled and restricted environment to perform/analyze a non-trusty application/task/whatever can run on a computer.
They are mostly implemented with virtual machines, because they are like an actual physical system, which can be easily set up and monitored.
Another way is Secure Computing Mode (seccomp), mentioned in the same wikipedia page:

Its a sandbox built in the Linux kernel. When activated, seccomp only
  allows the write(), read(), exit(), and sigreturn() system
  calls.

Quoting from Wikipedia page about Operating-system-level virtualization

Then, there is the well known Operating-system-level virtualization,
  also known as containerization. Its an operating system feature in
  which the kernel allows the existence of multiple isolated user-space
  instances. Such instances, called containers, partitions,
  virtualization engines (VEs) or jails (FreeBSD jail or chroot jail).
  They may look like real computers from the point of view of programs
  running in them. A computer program running on an ordinary person's
  computer's operating system can see all resources (connected devices,
  files and folders, network shares, CPU power, quantifiable hardware
  capabilities) of that computer. However, programs running inside a
  container can only see the container's contents and devices assigned
  to the container.

There are some other ways and applications that use sandboxing, like Java Runtime environment. Sandboxing and other virtualization techniques are used a lot for testing apps and environments before final release, perform many tasks simultaneously with less hardware, analyze malwares etc. I hope you get a brief idea of the uses and the extend of usability. Feel free to ask anythin else you want below!
Answer: Note: This answer is a supplement to @Forest's excellent answer to cover a few additional sandboxing techniques and technologies.
Sandboxing is, in general, the category of "actions that limit or contain the impact of some actor". The analogy is a child's play area, where they can make a mess in a contained, specified space. The definition as given above extends well beyond software (for example, if you see a driving video that says "professional driver on a closed course" or similar, the closed course is a kind of sandbox), but since this site is about information security, I'll focus on that aspect.
A very common sandboxing technique is to simply create a user account that has limited privileges. That user - and by extension, software they run - can't modify or even read most of the system. If you do this specifically to contain either an untrusted user or an untrusted program (which you run as that limited user), this is a kind of sandbox. This is, for example, standard practice with many kinds of network servers, even if you aren't using any other sandboxing. It's also how some early mobile device app sandboxes functioned, before things like seccomp were common. Essentially, each app has its own account, with its own (read-only) install location and (read-write) data location, neither of which any other sandboxed app can read. In fact, the only thing that a sandboxed app can access other than its own directories is system files and libraries that don't hold sensitive data. This approach is simple; multi-user operating systems have supported multiple accounts and access controls since their inception. However, user access controls often only restrict access to files and similar resources (e.g. on Windows, also registry keys, named pipes, and other securable objects), but not to system calls or things like another process' listening sockets. User permissions are what is generally termed discretionary access control, where access is limited based on who the subject (user) is, as opposed to mandatory access control based on the executable itself.
Windows also supports a concept called "mandatory integrity control", where an executable can be flagged as having a certain level of trustworthiness, and a process's integrity level is the lesser of the integrity level of the executable and of the security token of the process launching the executable. Securable system objects (files, registry keys, etc.) can be off-limits to processes below a certain integrity level, no matter who owns them (mandatory, rather than discretionary, control). By default the policy prevents writing (but not reading) objects of higher integrity, but this can be set on a per-object basis as part of the access control list.
API sandboxes are a common approach where you want to allow untrusted software to run. The most common is probably the Javascript sandbox in browsers. In addition to the browser sandbox that is built on OS features, the first line of defense against malicious JS is that it just can't do most things. You mostly don't have to worry about what file system access it has, because it doesn't have file APIs. You mostly don't need to worry about it accessing other processes because it doesn't have APIs for that either. Its network APIs are very limited: HTTP[S] client (including WS[S] client) only. This is part of what makes it safe to run untrusted script on the web. You see similar API sandboxes in a lot of other places too, though. Some languages offer the ability to restrict what APIs can be used, such as Java's SecurityManager , or restricting the available APIs in Lua.
Another important aspect of sandboxing is resource quotas. These are often OS-dependent (though some languages support them directly). For example, Linux has the prlimit feature (user command or system call) which restricts what resources a process can hold, and Windows has "job" objects to which processes can belong that can have similar quotas. You also see user quotas on shared systems (or when using account-based app sandboxing) sometimes, limiting how much storage a user can consume or how much RAM/CPU time/network IO/etc. they get across all processes, per some unit time. This is much lighter-weight than options such as creating an entire VM that only has access to a limited number of CPU threads and limited amount of RAM and disk space. Such quotas are useful both for security reasons (prevent a malicious actor from causing denial-of-service by using up system resources) and for general availability (prevent memory leak bugs from eating all the RAM, or kills task that accidentally end up taking too long and impact other system tasks).

How is Sandboxing implemented?


Random Walk with normal increments and n time periods why is the increment $\sqrt{(t/n)}$?

Question: Question is basically in the title. I have found several sources stating that $R_i = \sqrt{\frac{t}{n}}$, but I couldn't find the intuition behind taking the square root. And it seems to be crucial since $\operatorname{E}\left[{R_i^2}\right]= \frac{t}{n}$ and from there derive the variance of the Brownian motion as being $t$.
Comment: hamilton's text had a nice description of going from discrete random walk to brownian motion. So, check that out. It's essentially for the reason you mentioned :   In the discrete case ( RW case), you need that for the RW to be consistent with brownian motion in the limit as the timestep goes towards zero.
Answer: I don't think I was clear in my comment so I'm putting it in an answer to have more space. The variance of a brownian motion, z, is $t$. (i.e: $E(z^{2}) = t$ ). Notice that
$R_{i}$ really equals $\sqrt{\frac{t}{n}} \times \epsilon$ where $\epsilon \sim N(0,1)$. I think they leave the $\epsilon$ out because the variance is 1 but showing the consistency is clearer if we define it that way.
By definition, brownian motion is defined as the sum of a bunch of random walks as the step size goes to zero. So, given the definition of $R_{i}$, you end up with the variance of the sum, being $\sum_{i = 1}^{n} \frac{t}{n}  = n \times \frac{t}{n} = t$. Therefore, in the limit, the sum of the n random walks  is consistent with brownian motion as the step size goes to zero because the expected value is still zero and the variance is $t$.
Answer: My intuition is that the term $\sqrt{dt}$, is a result of Brownian Motion's properties. Total variation of the Brownian Motion is unbounded and therefore $TV \to \infty$. However the Quadratic Variation is bounded and $QV \to t$
Comment: Can you explain maybe further what you mean by a result of the Brownian Motion's properties? Is there are proof that the increments are sqrt(dt)? Or what exactly is the link to the quadratic variation?
Comment: I think you were asking Coxswaiiin but I changed my comment to an answer and that may answer the first part of your question. As far as the second part,.I don't think the quadratic variation plays a role in the OP's question.


Can't access aspx page after IIS reset using computer name only ip and localhost

Question: After installing a fix in a site, and doing a iis reset we are unable to access (gets 401) the site using the computer name. Accessing using the ip-adress or localhost works fine, and it worked fine before the iis reset. Other sites on the same server workes the only difference is the port. Does anyone here had the same issue of can point me in the right direction.
Answer: Are you still able to resolve an IP if you ping the name you are trying to connect to from another workstation because it sounds like a DNS issue. What version of IIS are you using? Have you checked to see what the host header value is for the other sites? Since you can access the problem site by IP, there is no host header value specified for the problem site. In IIS 6.0 open the IIS admin tool, right-click the website -> properties. click Advanced (next to the IP) and verify the host header values are correct. You should require host header values on all sites since most automated scanners scan by IP address and do not provide host header values unless you actually need to access the site via IP. It's a small step to drastically improve the security posture of your server.


Getting rid of a chess addiction

Question: How do I get rid of achess addiction? Both winning and losing just make me play more, and in the end, after many hours of play, I feel miserable.
Comment: The main reason of most addictions is the lack of social interaction. Do you have friends, work, school or anything else to spend your time on?

If you are unable to join a chess community in order to gain some social interaction in your life, I recommend starting another hobby that includes going outside and meeting people. That is my experience.
Comment: I just add that you should not feel to bad about the addiction *per se*, because nontrivial games, particularly non-chance, perfect information variants such as Chess, are widely regarded to be intelligence building, with the history of Artificial Intelligence as an algorithmic validation of this idea.  Even [Confucius felt there way value to these games!](https://www.quora.com/What-did-Confucius-say-about-the-game-of-weiqi-Go), and he is still regarded as one of the great sages.
Comment: @Laska it's promoting behaviour that is illegal on many sites and unsportsmanlike.
Comment: Let me just put this literally: play less chess. Eventually, you'll feel that you want to play it more. Worked for me.
Comment: see a shrink.  they can help you solve addiction.
Comment: I can see your point of view @glorfindel but I don't think letting the post remain implies promotion and I don't think it's always unsportsmanlike to do this. It depends on the site and the context. There are certainly situations when it would be antisocial and should not be done in my opinion. I should say I have never done this myself under any circumstances.
Answer: You are probably referring to online chess and I know this problem, because I've suffered from online chess adiction at least a year or so.
It helped me to realise that those imaginary rating points online are not worth anything and that playing at fast time controls does not improve your chess (too much bullet might even harm it).
Therefore, I suggest, you approach chess a bit more seriously over the board, so you have successes you can be proud of. This means that you don't need the kick of online chess anymore, or at least that was the case for me.
Try finding something that makes you happy when you do it. For me, it is, at least sometimes, to be productive in any kind of way (choose an area of your liking) or to simply relax or hang out with friends. Generally speaking, playing lots of online chess is one of the LEAST PRODUCTIVE things you can do and nothing that will propel your skill in any area. Hanging out with your friends for instance, is a much better way of spending your time.
I mean, I could go on about this, but those are my initial thoughts. If you have any specific questions about how I got rid of my online chess addiction, you may as well shoot me a message.
Comment: There is no golden recipe, but it is a good start to acknowledge what a waste of time it is, already by the first game.
Another way is to get rid of your mouse. Then your'e too slow and will be so angry about losing on time too often, that you stop playing.
Another way might be to install "cold turkey", a program that blocks certain websites for a predetermined period of time.
Also, take some of the advice I posted above.
Comment: Why do you say that "playing chess online is one of the least productive things"? It can be both fun and instructive if you play the right time controls with what you aim to improve. Chess is a hobby and a passion after all, it's not like OP is smoking crack
Comment: @postnubilaphoebus I'm new to the game, but I seriously wonder about the veracity of your claim.  A chess game is merely the sequences of moves by opposing players.  Why does "online" remove its value at helping one improve skills?  Why must we handle physical pieces?  If I play with long time controls online, how it is less experience-building than an OTB game?
Comment: @TomServo
That is a good question! I would say, it depends. Most online chess revolves around playing Blitz or Bullet games and they often resemble the fast-paced environment that is more akin to gaming (the kind that can be addictive, involves losing streaks and tilting). In Blitz or Bullet you just demonstrate the patterns you already know. Only longer games (rapid or long time controls) require you to challenge your assumptions, find a plan, calculate more and play "deeper" moves overall. In essence, long games teach you how to think properly and for instance avoid rumination.
Comment: What are the list of things to do to get rid of online chess addiction that is just a click away.
Comment: I just rated it on a productivity scale. That does not mean that playing online chess cannot score very high on eg a fun scale.

Concerning the improvement part though, I stay with my opinion. Online chess does not really help you to improve your skills.
Comment: @TomServo
So yes, online chess can also be productive and help you improve.
I personally do not like playing long games online because there are a lot of cheaters and I'm often too lazy if the game does not involve real rating points. But if it works for you, that's great :)
Answer: A suggestion would be to delete your account on the website you are playing. It's hard to click "delete", losing all your statistics and games, but after it's done you might feel like going back to the point you were before would take too much time, so you decide to do something else instead.
I had this issue with a particular video game, I decided to delete my character and never played the game again. I had urges, but I felt like it would take too much time to get back where I was and I didn't want to redo the same things I did before. I mean, you can easily rank up in chess with a new account, but the idea is that you might not want to do it.
Comment: @HighlyRadioactive can you expand a bit on this? Why wouldn't you want people to delete their account? Does it have an impact on you?
Comment: Good suggestion but -1 because I don't want people do this.
Comment: For some people it may not work, it will haunt them for an entire life instead. I know this because I once did.
Answer: "How do I get rid of chess addiction? Both winning and losing just make me play more, and in the end, after many hours of play, I feel miserable."
You have a very solvable problem. 'many hours of play' is the real culprit.
Limit yourself to a set timeframe. I won't play more than an hour or so in a day, which for me, would be 2 games at a time control of G15 (15 minutes per side for entire game). I find it gives me enough time to play reasonably, and the games are enjoyable.
With the following time controls, in 1 hour you can play:
G3 - 10 games
G5 - 6 games
G10 - 3 games
G15 - 2 games
G30 - 1 game
An important aspect of this is that with G10 and slower, you should always review your games. Spend any additional time after playing on this and learn something.
Chess is to be played and enjoyed.
Answer: If you are playing online, one thing you can do is to make a password like "dontplaytoomuch" or something. It sounds silly, but having this sort of password (I mix it up with numbers, for any hackers watching) is a small but nice nudge. There are studies showing these small things can add up, which is fortunate, because so often small things can send us into a time wasting spiral.
Addictive behavior in general is tricky to deal with, and it's important to recognize when you are just playing out of inertia. Often this becomes obvious if you make a really dumb mistake. There's a double benefit to this: you save rating points. Maybe you can even step back and look to improve your game.
But regardless of how your addictive behavior invades your life, there are ways around it. For instance, I caught myself playing FreeCell to put off things I needed to do, so I

deleted the Windows Freecell.exe app
installed a SiteBlock extension for my various web browsers to avoid a certain freecell site. I googled "add-on to restrict time on a website" and found some nice ones. Now, you can use a password to re-enter a site, but the point is, it's deliberately intrusive and difficult.
Finally, I wrote a FreeCell game in Python, to learn something. You may not want to take the drastic step of writing a chess engine, but I know I played chess out of inertia a lot, forgetting the main reason I played it was that I could learn and enjoy trying new things. So maybe you need to evaluate something you really want to learn that might give you the same happiness you used to get from chess.

Other points:
 - this may seem paradoxical, but set aside a half-hour per day for playing games. If you can stick to it, this will help you feel you aren't totally missing out.
 - I don't know if you have options to set up a profile, but even typing "I like to play chess, but sometimes I lose track of time play too much. If I've been on for an hour, and I challenge you, can you poke me to get back to work?" may help. This is true without beating yourself up, and maybe it will help other people get back to stuff you need to do.
 - Write a program to kick yourself out after an hour, or you might even ask on various channels if someone has written a time-management program that allows you an hour per day. You probably aren't the first to ask about this!
There are many tools out there to help you. But as @postnubilaphoebus says, and @Habbo commented, it's important to recognize there are better ways to spend your time. Playing chess has definite diminishing returns to scale.
Having goals outside chess helps. Maybe it is just getting through a book before it is due at the library, or working out, or connecting with old friends, or making new ones. If you're worried you might not be good at it, well, you're not alone in getting sucked into online life.
The main thing I've found with addictive behaviors is framing it as "I want to give myself a reason to do something cooler" works a lot better than "I have to stop doing this."
Good luck! I think all of us chess players can be prone to going into a chess-playing shell, so don't be too ashamed of getting in a rut even if it's lasted a while. I hope you get lots of other suggestions on this topic, because moving on from habits that aren't quite as fun any more isn't as easy as it seems it should be. And some things work much better for some people than for others.
Answer: I gave the password of my online chess account to a best friend.  She controls when I can have access to my online chess app.  I can create a new account, however, I don't because I want to play with my existing account, which has a long history.  It worked. I ask her for it during the weekend and in the evening. It was the last measure I had to do after everything else failed.  Online chess can be very addictive.
Answer: Here's a search engine trick that may help. You can block and unblock websites, so maybe you can block the chess site you're on, take a rest for a few days, and then unblock and start playing again. You don't have to delete your account.

Getting rid of a chess addiction


How can I determine the rpm of a wheel that's spinning really fast?

Question: Let's say that I have a motor that's spinning really fast. I really want to know the angular speed of the motor. Using a stopclock definitely won't work as no one can time such fast rotations. So how would I find the rotational frequency in such a case?
Comment: Well, if your rotation is "really fast", than this must be "really hard" to measure. Maybe you could  use a device which is "really fast" as well. Does this help answering your question? Maybe you could add numbers so people know what "really fast" means. In addition, you should tells us the aim: The solution depend e.g. on the price of your machine. If you got a machine for half a million USD, you are probably not looking for a cheap solutions.
Comment: It would also help to know the desired accuracy of the measurements.  If you're measuring a small fan at 10,000RPM as @SomeoneSomewhere mentions, you probably aren't too picky about being off by 100RPM.  If you're running a Zippe-type Uranium centrifuge at 90,000RPM, pushing the limits of the tensile strength of Titanium in the rotors, then you probably want to know your RPMs to within 1RPM so you can properly control them.
Comment: It would help if you described what you mean by 'really fast' - mains powered motors often spin at just under 3600 RPM, well above your method's ceiling. Universal motors, small fans, and many other things can spin at upwards of 10,000 RPM.
Comment: If you're looking for practical, you can probably find RPM counters that work with a piece of reflective tape at your local tool store.  Computing angular momentum from there is just a matter of math, and they measure significantly quicker rotations than a smartphone can strobe its flash to find.
Comment: Assuming the motor (or at least the shaft) is visible, attach a disc with a marker. You can have a dab of paint, a hole, or a magnet for a hall-effect sensor. For "really fast" you use a strobe light, or or count events (light shines through hole, magnet passes sensor).
Comment: It seems like you can also measure the sound frequency coming from the rotating object. See this video: https://www.youtube.com/watch?v=OWCAlJ1vsqc. I'm not sure that this approach is sound, though. It also won't work if the rotating object is homogeneous.
Comment: Baumer Hubner is a company that produces encoders, different kind of them. See http://www.baumerhuebner.com/download.0.html?L=1&suchstr=OG_6 for some of them.
Comment: @SomeoneSomewhere My method is only limited by the capacity of my phone's strobe frequency limit. With higher frequency strobe lights, faster angular speeds can be measured.
Answer: There's a very interesting way to find the angular velocity of a wheel that's spinning so fast that you can't measure using a stopclock. We'll be using a strobe light (a light that flashes on and off repeatedly) and a very interesting concept known as the Wagon Wheel effect under stroboscopic conditions.
A little bit about the concept:
The Wagon Wheel effect is a phenomenon in which a spinning wheel may appear to be stationary under a strobe light. The reason why this happens is quite simple, the rotational frequency of the spinning wheel is an integral multiple of the the strobe light's on-and-off frequency. As a result, every time the strobe light flashes, the wheel comes to the same position as before. This creates the illusion that the wheel was stationary.
But how will we use this concept to find the rpm of a spinning wheel? Let's find out.
The experiment:
You'll only need a strobe light (you can download strobe light apps for Android and probably for iOS as well) and your spinning wheel. In this answer, I'll be using a fidget spinner to demonstrate.

Keep the room as dark as possible, and set your wheel to motion. Turn on the strobe light and start with a high flash frequency and gradually lower the frequency until you see the wheel become stationary. We do this because don't want other integral multiples of the frequency to match up with the spinning wheel.

Take a note of the strobe light frequency $\nu$. In my case, the fidget spinner appears stationary at a frequency of 13.3 Hz. As we mentioned before, the wheel appears stationary only when the frequencies match. So, the frequency of the strobe light is the rotational frequency of the wheel. So, I can say that my fidget spinner makes 13.3 revolutions per second. And of course, it's rpm would be 798.

I hope you enjoyed this fun experiment. If you have any queries, please drop them at the comments. If you have a better way to find the angular velocity, don't hesitate to write an answer.
Comment: Note that for a proper experiment whose data you want to use, you'll need to know how accurately the strobe frequency is displayed, otherwise you become unable to honestly estimate the error on the measurement.
Comment: I think you can also determine if you're synchronized, or at some multiple, by slightly changing the strobe frequency and then observing how the speed of the object appears to change. For example if the strobe is reduced by 1 Hz but the object appears to change by 3 Hz, you can deduce the ratio of strobe to object is 1:3.
Comment: Actually, if the wheel's angular velocity is steady this method will be very precise, since a small detuning will be visible as a small but noticeable drift.  However, as described, the method will strictly speaking only give you $f/n$, where f is the frequency of the wheel and n is some unknown positive integer (if you know you're starting close to the rotation frequency then n will be 1, but if the wheel is spinning "very fast" then the strobe frequency may be many times lower).  However, if you measure f1 = f/n1 and continuously shift the strobe frequency until you find the *next* ...
Comment: ... higher frequency f2 that makes the wheel look stationary, then f2 = f/(n1-1).  That gives you two equations in two unknowns, and you can solve for f.  So even if your strobe isn't nearly as fast as the wheel you can still get the wheel's rotation rate.  (Or, if the next higher frequency gives a double-image of the wheel, then f1 was the actual wheel frequency in the first place.)
Comment: Thanks for your insight @ACuriousMind. I wasn't really so keen on the accuracy of the frequency displayed by my phone. Of course, this experiment is not without limitations, as it is mainly a non-sophisticated experiment, which can be done with easily available household items. Thank you for your advice nontheless.
Comment: This will allow you to estimate frequencies quite a bit higher than just counting revolutions but it's still quite limited. Even a 50Hz strobe (a.k.a. LED lightbulb) looks like continuous illumination to the human eye.
Comment: @PhilFrost Sure, but if your wheel's spinning at 600,000rpm then it's going to be doing many rotations during each firing of the strobe, anyway. Measuring that kind of rotation speed is going to be a significant challenge with any equipment!
Comment: I've seen a lot of people are emphasizing the limitations of this experiment, such as the limited angular velocity that can be measured this way. I'm currently thinking about ways to extend the limit, while still using this method. I'll be making an update in a little while.
Answer: A laser tachometer:
https://www.amazon.com/Neiko-20713A-Digital-Tachometer-Non-contact/dp/B000I5LDVC
Make a mark at one point on the motor, then set it spinning. Point the tachometer at it. By shining a laser on the surface and measuring the changes in returned light as the mark passes, it can determine the RPM.
Comment: @PrittBalagopal The fundamental difference really lies in accuracy. A purpose-built device is going to give more accurate answers than eyeballing it via strobes, and they're really not even that expensive these days. It's really a matter of the application involved. Do you need to know that it's 9998 RPM vs 9999 RPM? Or are you just curious about how fast it's going? I can easily see how both answers could be useful depending on circumstances.
Comment: @PrittBalagopal No, this is completely different to your approach. The approach here is just to watch the thing spinning and count the revolutions, but to do it with an optical sensor that can count much faster than the human eye. Also, your eyes can't distinguish a very fast strobe from continuous lighting (e.g., an LED lightbulb is basically a mains-frequency strobe, but you see it as continuous light).
Comment: @PrittBalagopal suppose the "really fast" rotor is spinning at about 100,000 RPM. That's about 1600 revs per second. There is no way a cheap strobe light can produce any useful light output at that frequency, but a very simple photodiode detector can easily convert one reflected flash of light per rev into a 1.6kHz electrical signal, and any PC or cellphone can measure the frequency by connecting that signal to an audio input.
Comment: Well for one, his will be a continuous beam - the flashes come from having a reflective fiducial marker on the rotating object.
Comment: @PrittBalagopal If you point your phone at a 3000 (or 3600 if in a country with 60Hz power) RPM induction motor, you're not going to see anything useful. This will quite happily tell you. Plus, it doesn't have to be in a dark room, it's faster, and you don't have to do any maths.
Comment: I would also watch out for symmetry in the thing spinning. The fidget spinner in the photo has different colours but if it didn't it would be easy to get the frequency out by a factor of 3!
Comment: This answer is very similar to my approach, using high frequency flashes of light. Can you explain how your answer is fundamentally different from mine?
Answer: One idea for an approach may be to record the sound the motor produces and then Fourier transform that signal. The assumption is that the frequency you look for will be prominently visible in the spectrum of that signal. Of course, it is not clear whether this frequency is as easily identifiable as it sounds.
Comment: Related: https://engineering.stackexchange.com/a/2009/846
Comment: You have an interesting idea too. I have always noticed that fast spinning motors "squeal" at higher pitch compared to slower spinning ones. Can you explain this in more detail?
Comment: @Emil: That is a very nice and practical realization of this approach with much more explanation. I did not know that there are smartphone applications that can be used to do this. But thinking about this I should have known. Thank you for the link.
Answer: Print out a disk that looks like this:

Attach it to the spinning object and then observe it with a 60 Hz strobe light. By determining which rings look like they are stopped by a 60 Hz strobe you can deduce the RPM of the object.
As you can see, the inner ring has 8 segments (4 white, 4 black), the next ring has 10 segments etc. If you rotate the disk by 90 degrees, the pattern on the inner ring won't have shifted. If you rotate the disk by 72 degrees, the pattern on the next ring won't have shifted. So, with a 60 Hz strobe, you can find which ring appears to be stationary. Call the number of segments in that ring N, then the disk must have moved 720/N degrees in 1/60th of a second. that's 2/N revolutions in 1/60'th of a second, so 7200/N RPM.
Do a web search for "printable strobe RPM" for more details.
Comment: This answer would be greatly improved by including at least a sketch of how this method works.
Comment: I wouldn't call 1800 RPM "really fast." A car turbocharger rotor can get close to 100,000 RPM, for example. And in any case,  turbochargers are much too small to attach that type of strobe disk to them.
Answer: I happen to have done this exact experiment over the weekend - detailed write-up below. Basically it involved a laser pointer, a photo diode, two resistors, a transistor, and an Arduino. Set the Arduino timer to run at 10 kHz, and the output of the photodiode (into the interrupt input of the Arduino) triggers a "read" of the timer. When at least a second has elapsed, you print the ratio, reset the counters, and start again. Works really well over large range of RPM. I actually used it to measure the spindown of a fidget spinner - to demonstrate that the process is nonlinear, which proves that air drag plays a role.
Here is a picture of the "setup" (on the messy desk in my "den"):

A simple cardboard box was holding a photo diode on the left (20 pieces for \$4.99 on Amazon *), and a small laser diode on the right (10 for \$6.99 on Amazon). I could hold a rotating fidget spinner in the beam, and the Arduino would do the rest.
And a scope trace of the signal: (a bit blurry - the scale is 20 ms per division, so there are about 30 interruptions per second as I took the picture)

Obviously it helps to have a scope to set something like this up properly - but if you have a laser pointer that is pointed at your photo diode, and a way to interrupt the beam properly as the wheel rotates, you have quite a lot of leeway.
UPDATE
Here is the Arduino code I used to create the RPM meter:
<code>// code to create an RPM meter based on an interrupted optical beam
long time=0;        // time since last measurement
long clicks=0;      // optical interruptions since last measurement
long totaltime = 0; // total elapsed time since reset

void setup() {
  // configure pin 2 for input:
  pinMode(2, INPUT_PULLUP);
  attachInterrupt(0, reportTime, FALLING);

  // setup timer:
  cli();//stop interrupts

  // set timer1 interrupt at 10 kHz
  TCCR1A = 0; // set entire TCCR1A register to 0
  TCCR1B = 0; // same for TCCR1B
  TCNT1  = 0; //initialize counter value to 0;
  // set timer count for 10 khz increments
  OCR1A = 199;// = (16*10^6) / (10000*8) - 1
  // turn on CTC mode
  TCCR1B |= (1 << WGM12);
  // Set CS11 bit for 8 prescaler
  TCCR1B |= (1 << CS11);
  // enable timer compare interrupt
  TIMSK1 |= (1 << OCIE1A);

  sei();//allow interrupts
  //END TIMER SETUP

  // turn on serial port at 9600 baud:
  Serial.begin(9600);
}

void loop() {
// nothing here - everything is interrupts
}

void reportTime() {
  clicks++;
  if (time > 10000) {
    // at least a full second has passed
    totaltime += time;
    Serial.print(totaltime);
    Serial.print("\t:\t");
    Serial.print(600000*clicks/float(time));
    Serial.write(" rpm \r\n");
    time = 0;
    clicks=0;
  }
}

ISR(TIMER1_COMPA_vect) {
  // Interrupt at freq of 10 kHz
  time++;
}
</code>
The circuit diagram is super simple. I attached a 5 V supply to the laser diode module (which has its own internal current regulator); it's possible it could run off the Arduino 5 V (it only takes 10 mA) but I didn't try that. The optical pickup was done with this circuit:

When the diode is illuminated, the current is split between R1 and the base of the transistor. Once the voltage across R1 reaches 0.6 volts, the transistor will "turn on" and pull current from the collector. This pulls down the signal that is connected to pin 2 (using the internal pullup of the Arduino). When the beam is interrupted, the current is reduced and the transistor turns off. Turning "on" (pulling down) is much faster than turning "off" with this circuit, so we trigger off the falling edge. You can make the circuit more sensitive by increasing R1 - the bigger it is, the smaller the light level needed to trigger. But it also becomes more sensitive to ambient light, and response is slower. With the laser diode, I found that 420 Ohm was a good value: fast response, insensitive to ambient light. But that's definitely a value to play with.
I tested the circuit at frequencies up to 1 MHz (driving the laser with a signal generator with a square wave), and it was fine - so the response time is well below 1 us. This should make it fast enough for many applications.
An example of using this to measure the RPM of a fidget spinner:

There are 3 interruptions per revolution on the spinner - and I have no problem measuring 1200 rpm (3600 interruptions per minute = 60 per second). Driving the laser with a signal generator, I was able to go much faster... up to 30 kHz. At that point, there is some overflow in the program and the numbers are nonsense (I suspect that the Arduino isn't fast enough to deal with 10,000 clock interrupts and 30,000 optical interrupts; some changes to the scaling might extend the range, but you won't need that for most purposes).
Running the laser at 1 kHz, I was seeing 59988 rpm - that is obviously "60,000" with some numerical rounding error (or the clock on the Arduino is not exactly 16 MHz, or...), so that is good. When you push the circuit too hard, interrupts will be getting in each other's way. The highest "correct" reading I obtained was with 3 kHz input, 179904 rpm output. That should be good enough for most applications... Even a bike wheel (with 32 spokes) going 100 revolutions per second (approx 2/3 of the speed of sound) could be timed with this. Of course the wheel would tear apart long before it reached that speed...

* I am not affiliated with Amazon or the companies making these components; just wanted to make it easy for you to find such parts
Answer: Attach your motor to a reduction gearbox.  Measure the angular speed of the output and multiply by the reduction ratio to get the original angular speed.
Note that people are currently 3-d printing 11 million:1 or billions:1 reduction gearboxes.  Example.  Also, the output of a gearbox can be the input to the next one (although one should be aware of frictional losses and minimal required torque), so ridiculously fast motor angular speed can be reduced to essentially stationary output.
Comment: I think this is the correct answer if one needs repeated measurements.
Answer: Attach a DC motor, and measure its EMF, by plotting the voltage you measure at the connections you would typically supply the DC motor, had you used it as a motor.
Most simple DC motors have 3 coils, so on an oscilloscope you will see something similar to the absolute of a sine, where three such "hills" will correspond to one full revolution.

It is probably much simpler to install than a gearbox, and you will have much less trouble with friction especially if the speed is really fast.
Answer: My first attempt would be a slow motion video on my smartphone, count the revolutions for 10 seconds and times it by 6 to get an idea).
The framerates could be too low for you though. (There's a new Sony smartphone with a 1000 frames per second drool, that's like 60,000 frames per minute. The Samsung S5's has 120fps.).
Answer: My take on this question is based on this video. The idea behind this is that if you manage to transfer the angular velocity from the motor to a spinning disk and create the setup from the video, you can, based on the geometry of the setup and the precession velocity, calculate the angular velocity of the motor.
The calculation can be found here, pages 4-6, problem W14D3-2 Table Problem Suspended Gyroscope Solution. At the end of the problem you have the following formula where all the parameters are defined in the document:
$$\Omega=\frac{d\cdot m\cdot g}{I_{cm}\omega_s}$$
For your scenario, you can use the above formula, but to compute $\omega_s$ by measuring $\Omega$.
I hope this adds a different perspective to the problem than what was suggested so far.
Answer: As seen, there are dozens of experiments that might help you, but a more simple and fairly accurate way can be by attaching a very small light at any random point of the wheel and turn it on. Then you can spin the wheel at your desired rpm and attach a sort of a light sensor of a high intensity (equal to the small light attached on your wheel). Then the sensor can count, in how much time the light of given intensity was detected, you can modify it such that every time a light beam of given intensity is detected, the sensor would mark it with a beep, and count the total number of beeps.


What is definition of done in automation testing?

Question: Team,
What is definition of done for automation testing?
For example, do we consider execution time or test case coverage?
Comment: You list scenarios you want to automate and you consider automation as done when you automated those scenarios. Which scenarios to automate is, of course, a completely different question.
Comment: DONE is whatever your team decide it is. There is NO replacement for proper communication, and no opinions from from intewebz will change opinions of your team-mates. Books were written about the subject.
Answer: Automated testing is done when all the current functionality is covered by the tests, i.e. test case coverage.  When the automated testing is done I always recommend manual testing on top of this.
If you have specific performance and/or load tests they will have criteria as to whether they are passing or failing, i.e. completing within the time specified.
Answer: Prior to automating a test case/test pack the checkpoints must be agreed. If you are purely automating a functional test case which does not validate how long it takes between one step and the next, in that case as long as the agreed journey is automated and functional checkpoints are met, the test case/pack is considered to be completed from scripting perspective. But if you are automating a non functional requirement/test case then it is important to have the response time validation in place.
I consider and approve any test case to be automated when it gives the same test result as a manual test.
Hope that helps, best of luck.
Answer:
automation testing

automation testing is simply another type of a software project, as such it should use the same DoD of software projects adjusted to the relevant context.
Some common examples-

Documentation
The code was reviewed and approved
Unit tests covering % of the code in some way or another (yes, automated tests usually need their own set of unit tests)
The code was tested and approved

Some common, but specific to your implementation, examples-

Functional requirements are covered
Non  requirements (if exist and if applicable) are covered

Naturally, like for any other software project, requirements are almost never complete so the team will need to use some common sense when deciding when a done is done.
Some tasks are simple, operating in a simple environment and as such can be considered done-done easily, while some tasks are complicated operating in dynamic environments and as such can be considered done but with followup tasks.
To use your question as an example execution time could be important factor of projects with many tests where all tests must run for every test run while for some projects execution time is almost meaningless.
Test case coverage is obviously important, but it is as good as your test cases- if something is left open in your test procedures then you can't objectively consider it done.
Answer: Your question seems to suggest a misuse of the definition of done. The DoD is applied to every product increment. In Scrum, the intent is that each backlog item builds onto the product and is therefor subject to the definition of done for that product.
The team identifies items that should be in the definition of done for the product to meet an appropriate quality standard. This will include items such as "x% automated test coverage" and "all automated regression tests run and pass" and it will also include things like "code has been reviewed" and "any architectural changes are reflected in the documentation".
DoD is not applied to different tasks.


Steam Powered Door

Question: I'm no engineer, but I was wondering how a steam-powered door would work. I want it to be difficult to open unless you know how (not a simple "twist the doorknob and open"). There is access to plenty of water and fire in this scenario as well.
Answer: Hero of Alexandria (c. 10 CE – c. 70 CE) was a Greek mathematician and engineer who was active in the 1st century CE in his native city of Alexandria, Roman Egypt.
He wrote several books describing very advanced machines, including a fully automated theater play performed by marionettes actuated "by a binary-like system of ropes, knots, and simple machines operated by a rotating cylindrical cogwheel" (Wikipedia).
More inline with the question, he described an engine which "used air from a closed chamber heated by an altar fire to displace water from a sealed vessel; the water was collected and its weight, pulling on a rope, opened temple doors". (Wikipedia)
The construction of the machine is described in his book, Pneumatica, section 37.

The construction of a small temple such that, on lighting a fire, the doors shall open spontaneously, and shut again when the fire is extinguished. Let the proposed temple stand on a pedestal, A B C D, on which lies a small altar, E D.
Through the altar insert a tube, F G, of which the mouth F is within the altar and the the mouth G is contained in a globe, H, reaching nearly to its centre: the tube must be soldered into the globe, in which a bent siphon, K L M, is placed. Let the hinges of the doors be extended downwards and turn freely on pivots in the base A B C D; and from the hinges let two chains, running into one, be attached, by means of a pulley, to a hollow vessel, N X, which is suspended; while other chains, wound upon the hinges in an opposite direction to the former, and running into one, are attached, by means of a pulley, to a leaden weight, on the descent of which the doors will be shut. Let the outer leg of the siphon K L M lead into the suspended vessel; and through a hole, P, which must be carefully closed afterwards, pour water into the globe enough to fill one half of it.
It will be found that, when the fire has grown hot, the air in the altar becoming heated expands into a larger space; and, passing through the tube F G into the globe, it will drive out the liquid contained there through the siphon K L M into the suspended vessel, which, descending with its weight, will tighten the chains and open the doors. Again, when the fire is extinguished, the rarefied air will escape through the pores in the side of the globe, and the bent siphon, (the extremity of which will be immersed in the water in the suspended vessel) will draw up the liquid in the vessel in order to fill up the void left by the particles removed.
When the vessel is lightened the weight suspended will preponderate and shut the doors.
Some in place of water use quicksilver, as it is heavier than water and is easily disunited by fire.
(Hero of Alexandria, Pneumatica, 37, translation by Bennet Woodcroft, London, 1851.)

Left, a 17th century German portrait of Hero of Alexandria. Right, a diagram illustrating Hero's pneumatic temple doors, as depicted in the 1851 English translation by Bennet Woodcroft.
Answer: Forget postulation; there's a real example of a steam-powered levering mechanism (in this case a bridge deck, but no reason why it couldn't be a door) within Tower Bridge in London.
London's Tower bridge is a Victorian steam-powered* bascule bridge; the bridge deck is moved (rocked/"basculed") using a cantilever and hydraulics system. The hydraulics system is powered using massive steam-operated driving engines, which drive the pumps which move the river water into accumulators (storage reservoirs). With the aid of the weight of the cantilever, the weight of the bridge deck is overcome and the deck is raised. The mechanism is so well balanced/engineered that it only takes a minute for the process to complete from the moment the operator engages the pump.

https://www.towerbridge.org.uk/Visit-Engine-Rooms/
https://www.towerbridge.org.uk/bridge-history/ (See How It Works)
Applying this to your original question, there's no reason why you couldn't do the same thing. In the case of Tower Bridge, the moving part is overcoming gravity. With a door, moving laterally of course, the force direction may be translated using a pulley. A steam pump puts some water into an accumulator, the accumulator drops, pulling the rope or chain on the pulley, the rope/chain on the other end is attached to the door which could, if you so wished, weigh tonnes.
In order for the door to return to its original position, an additional pump isn't  required; a static weight (similar in operation to Tower Bridge's deck) may be chained taking the door in the opposite direction; the accumulator's contents are discharged in order to have the process reversed.
Note that the mechanism itself may be placed a distance away (owing to the pulleys), possibly underneath the door itself, hidden from view. The driving mechanism also has the potential to be armoured (such as behind a stone wall or floor) in the scenario that it's a defensive feature; much the same way that drawbridge/portcullis mechanisms were hidden in castles.
Regarding your "difficult to open" requirement: with this approach it's down to your imagination. Could be twist to open, could be a hidden lever; a book or statue that requires to be pulled. You could even have tap dancing on a sequence of floor tiles, operating effectively as a combination lock**. Anything that could be used effectively as a switch to fire up the steam engine hidden in the neighbouring room.
*strictly speaking the bridge has been electric-powered since 1976, however it was originally steam-powered.
**"In the Latin alphabet, Jehovah begins with an I!"
Comment: ALL HAIL! Thank you! It works (in my mind) beautifully.
Comment: Cheers man; I wasn't sure if it was too complex and I needed a diagram to explain.
Answer: Well, if you want a puzzle or lock of some kind, then do that yourself, but the basic action of opening a door is still "Push/Pull/Activate (Input Device).
Steam is pretty good at pressurizing, but as with all gases, it will want to  expand before pressure starts to rise above normal. If you make it a bit longer than it needs to be to fill the doorway, you can fit a hollow space in the bottom. Place that over a chamber with valves to your boiler. When the steam is released into the chamber, it will push up the door with an action that might look similar to a trombone slide. When it's at the top, it can be locked and held in place. Lowering can be as simple as pulling a lever to release the lock.
Comment: And release the pressure in your sliding piston.
Answer: If you've ever seen the control panel of a steam locomotive, it certainly meets your criteria of 'difficult to {operate} unless you know how':

The ridiculous number of valves fundamentally does quite a simple job - regulates the flow of steam into a cylinder, where the pressure drives a piston. Many of the controls exist to prevent the boiler pressure exceeding safe limits.
Your simplest option, therefore, is to have an extremely heavy slider door, not unlike a blast door, which is opened and closed with a simple steam piston acting against the foundations of the building. The boiler must be fired up and brought up to pressure, then the steam can transfer energy to the piston to slide the door open. Difficulty to open can be achieved by not labelling any of the valves (which is evil in its own right!) and relying on some esoteric instructions, shapes, or mystic riddles to inform the protagonist(s) which are the correct valves to operate to cause the door to open (and should they get it wrong, a catastrophic boiler explosion is a good possibility). And because the door is incredibly heavy (just like the hundreds of tonnes of iron that form a locomotive), moving the door with anything less than its own power is impractical.
You could even store most of the moving parts on the other side of the door, leaving only the furnace and valves accessible (although do note that the moving parts have a huge appetite for oil, so in practical terms keeping these on the other side might mean the door seizes shut through lack of lubricant over time.

Steam Powered Door


Is there any possible way that hybrids can mate?

Question: I'm writing a book, and a a portion of it involves a society of humanzees. Now, is there any plausible way that a hybrid (such as a humanzee) could procreate either with one another, or with their father/mother species? I apologize for my lack of understanding of biology, any help would be much appreciated!
Answer: This is a hypothetical scenario which I think could be compared in parallel to hybrids like a mule (offspring of a male donkey and a female horse) or a hinny (offspring of a male horse and a female donkey) or zebroids (reference). In the case of the fertility of mules on wikipedia it is stated that

A few female mules have produced offspring when mated with a purebred
  horse or donkey.

with examples being given as

Since 1527 there have been more than 60 documented cases of foals born
  to female mules around the world. There are reports that a mule in
  China produced a foal in 1984. In Morocco, in early 2002, a mare mule
  produced a rare foal. In 2007 a mule named Kate gave birth to a mule
  son in Colorado. Blood and hair samples were tested verifying that the
  mother was a mule and the colt was indeed her offspring (reference).

In the case of a hinny fertility is much more rare but there is a documented case on Wikipedia

In China in 1981, a hinny mare proved fertile with a donkey stallion.
  When the Chinese hinny was bred to a donkey jack, she produced "Dragon
  Foal," who resembled a donkey with mule-like features (reference).

The wikipedia page on hybrids will also be of interest in your research. In short, hybrids can procreate and give birth in rare cases. However, I wouldn't vouch on the survivability of the offsprings. Since your work is fictional, it is entirely left to your discretion on that topic. Btw, humazee or humzee makes a more intriguing name maybe. Good luck with the book.
Answer: Recent genetic analysis of human DNA shows neanderthal ancestry, so inter-species breeding to produce reproductively viable offspring (humanderthals?) appears to be possible - at least between species of the same genus. But with Homo sapiens being the only extant species in the genus Homo you'd be really stretching the boundaries of plausibility to have a human/ape or human/monkey hybrid.


Font identification: On or off topic?

Question: We're starting to get quite a number of "What's this font?" questions, and I'm curious, do we as a community think they should hold, or should we just get rid of them?
Comment: I don't think finding fonts was the purpose (or related to the purpose) of this site, and beyond that, the Q&A format doesn't serve the "Find this font" question. I think we need to call these off-topic at some point.
Comment: It strikes me as ridiculously lazy. Google font finder and you get 10. "Find this font for me." is EXACTLY like saying "Tie my shoe." - I find the question degrading.
Answer: Discussion of typography definitely seems on-topic.
Being lazy and asking people to figure out a font name for them? Well, I guess it's still related. But there are very dedicated sites out there for that already (typophile and myfonts being the main ones).
I'd put it up there with "what's the keyboard shortcut for doing this in Photoshop?" Certainly a GD related question, but hardly a question that I'd consider high quality and generating a lot of interest.
Comment: The problem is that if you are looking for font related questions they are all drowning in a sea of "what font is this?" questions right now. Maybe one year ago there weren't so many of these questions, but they are clearly getting out of control. Also I don't think they will help anyone except the OP because a user would have to go through all the questions to see if any of them is the one they are looking for... this in turn leads to more "What font is this?" questions. Could be a serious problem.
Comment: I would tend to agree. The 'what font is this' question has ruined typophile as well. We should probably avoid those questions.
Answer: I think these can be on-topic -- so long as

they can provide an actual screenshot of the font (important)
there aren't too many, to the point that they dominate the site
these questions are a soft on-ramp for onboarding new members of the community

Some related discussion at
http://blog.stackoverflow.com/2010/11/the-pee-wee-herman-rule/
Comment: 2 is less of an issue if people add it to their blocked tags...  right?  Or from a macro level, is it bad for newcomers to come to the site and see a disproportionate number of a specific type of question?
Comment: I saw [this question](http://meta.stackexchange.com/questions/74645/display-tag-excerpt-when-asking-a-question) about displaying tag excerpts on mouse-over.  Has there been any thought to raising the visibility of the excerpts?  In particular, many font-id questions are answered with http://new.myfonts.com/WhatTheFont/ - which could be viewed in an excerpt directly from the question screen.  Many may not be aware of the mouseover trick.
Answer: I think they are on-topic, fonts are within the core of graphic design. Like the "How do I...?" questions, we just need to figure out the best yet still easy way to manage them.
At minimum, we just need to be sure to tag them properly when they come in so that people who want to ignore them are able to easily. Also, If no one has done it yet, we should put in the tag wiki for the font-related tags information on what makes a successful query along with a list of the websites people have been using to identify fonts.
Comment: I've made an initial suggestion for the tag wiki.
Answer: I believe they lack usefullness for other users as the questions lack searchabillity. A similair case came up recently on a the movie-site. "what movie is this" kind of questions.
Answer: I believe they are totally on topic but only useful if they are not so easily found.
I'm getting all my rep through font identification, it's a bit too easy :-)
Just a thought but could we request people to type the leads given by Whatthefont or Identifont before answering the question? It makes sure they did the work, saves us some time and if there are no leads well it's a tough question and might attract more expert attention.
Comment: Hey @curious, you should have just gotten an email from me inviting you to a pre-screening session hosted by Stack Exchange. We're trying to nail down a date before Friday, so if you are interested, could you let me know what times might work best for you?
Answer: I propose that we handle all future font identification requests like this:
We enjoy answering your design questions, we really do. However, we're no more capable than you are of finding the name of a font. Rather than being an intellectual question that we can answer for you, it's merely a chore.
However, in good faith, I've searched a (kinda close) match to your font for you: Vox Wide SemiBold from Canada Type Vox
It might not be the perfect match, but if you want a more precise match, you may need to do some manual searching.
Please see:

How can I automatically determine fonts used in an image or PDF?.
How to manually identify a font when the automatic services fail?

As a final note, remember, as some good logos use private or modified fonts, it may not be possible to find an exact match, no matter what you do.

Font identification: On or off topic?


set up performance monitor for a service

Question: On a windows server 2003 server, i have a particular service that's causing me a lot of heartache.  I was wondering if there was a way to set up performance monitor to track information for the service?  the specific service i'm interested in is Project Server Views Notification Service.
Answer: You can track the specific instance under the "Process" object corresponding to the PID of the program you're interested in tracking to get general statistics about the process (CPU, memory, IO). Unless the program exports its own performance counters, though, that's about all you're going to get. (There are "Thread" counters, too, but they're probably not going to tell you anything.)
Answer: Hi I think you want project server health monitor:
http://office.microsoft.com/en-us/project-server-it/project-server-health-monitor-tool-HA001164272.aspx


How to install Asterisk with SRTP support?

Question: I'm rather new to Asterisk, and I need my server to support WebRTC. As far as I know, Asterisk version in Asterisk Now is compiled without SRTP support, which is necessary for WebRTC.
So, I try to compile Asterisk 11.5.0 with SRTP on my Ubuntu server 13.04. I execute ./configure command with --with-srtp option. Here is this command:
./configure --with-crypto --with-ssl --with-srtp

But I get a warning:
checking for the ability of -lsrtp to be linked in a shared object... no
configure: WARNING: ***
configure: WARNING: *** libsrtp could not be linked as a shared object.
configure: WARNING: *** Try compiling libsrtp manually. Configure libsrtp
configure: WARNING: *** with ./configure CFLAGS=-fPIC --prefix=/usr
configure: WARNING: *** replacing /usr with the prefix of your choice.
configure: WARNING: *** After re-installing libsrtp
configure: WARNING: *** configure script.
configure: WARNING: ***
configure: WARNING: *** If you do not need SRTP support re-run configure
configure: WARNING: *** with the --without-srtp option.

My libsrtp (v 1.4.4) is already compiled with the options, mentioned above! I've also tried to set location of libsrtp, while configuring Asterisk:
./configure --with-crypto --with-ssl --with-srtp=/usr/include/srtp

but this changes nothing.
Can you help me with WebRTC support in Asterisk?
UPD: I think, there is a problem in SRTP library, because it does not pass runtest properly: Error 254.
They write, changing "RTPW=rtpw" to "RTPW=./rtpw" in rtpw_test.sh will fix this error, but it doesn't.
Answer: Did you install the development headers? You should be able to get 1.4.4 in the repositories and not have to compile from source. That is what I did although I am not on Ubuntu 13.04.
apt-cache search libsrtp

should hopefully yield either libsrtp-dev or libsrtp1-dev or something along those lines
Answer: In SRTP Folder
make uninstall
make clean
./configure CFLAGS=-fPIC --prefix=/usr/local/lib
make
make runtest
make install

Answer: Installing Gentoo and emerging Asterisk with srtp flag solved my problem. Any solution for Ubuntu was not finded, regardless on 2 days of earnest search.


Is it harmful to drive at high rpms

Question: Does driving at high RPMs (3000-3500) in a manual transmission car cause any extra wear and tear to any mechanical parts? It obviously hurts gas mileage, but does it hurt anything else?
Comment: Maybe you can add your engine green zone as stated in manual / marked on tachometer?
Answer: It all depends on your definition of high.
In my car, the red line is at 7500 rpm, and that indicates that driving with the revs over this line for anything other than brief periods is expected to cause damage, either through overheating, increased wear, increased loading on bearings, lack of sufficient oil/fluid flow etc.
When driving I have to keep my revs below 3000 until the engine and turbo are at the right temperature, then I typically keep my revs between 3000 and 5000, as that is the best range for it, but you need to look at what your car is designed for.
The maintenance intervals are defined by mileage, so as long as you follow the guidance in your manual on revs your engine should be fine. As Krom commented, your manual will often give a 'green' zone for engine revs - which will indicate where your engine should be running.
Incidentally, running at too low rpm can also cause problems, which is why the green zone may be 1500-3000 or 2000 to 3500 etc.
Comment: Great, thanks. I knew about the red line of course (mine is 6000) but didn't know there was such thing as a "green zone." I'll check my manual when I get home
Comment: It varies by gear as well...  Higher/taller gears require more RPM to not be in the lugging range.
Comment: Thanks. Sounds reasonable. Would you care to elaborate why you drive under 3000 and wait for the temperature to hit? What is the reason to not just hit 5000 from the start?
Comment: @jedatkinports - we have questions already on the site on this.
Comment: Whats the title of the question? Can't find it. :/
Comment: @JedatKinports - search on things like maximum rpm, engine temperature etc.
Answer: Within a certain range, of course more RPMs mean more wear. Especially if your maintenance is based on time or miles.
Consider a bearing that has a lifetime of 1,000,000 revolutions. If you drive at 5,000 RPM, that bearing is going to use up its lifetime twice as fast as if you were driving at 2,500 RPM.
On the other hand, "lugging" an engine at too low an RPM can be harmful, as well.
If your prime directive is mechanical lifetime, shoot for lower RPM within a reasonable range (i.e. not lugging).
Answer: The absolute most stress on an engine occurs at high RPMs. The forces acting upon the rotating assembly are exponentially increased with RPM. That also increases the magnification of any oiling inconsistencies (as small as they may be nowadays), which can be deadly to engines.
Increasing power (cylinder pressure) has a much smaller impact on engine stress, relative to RPM induced stress.
The lower the RPMs you can stay under (within reason*), the less stress your engine will endure. This is also why lightweight and balanced rotating assemblies contribute to much longer engine life at higher RPMs (eg. motorcyle engines, F1 engines).

Don't lug your engine, either!
Comment: "The lower RPMs you can stay within.." - this, I hope, takes into account avoiding lugging as a turbo on a Diesel engine, for example, will hate it on the mid or long term.

Is it harmful to drive at high rpms


Who prescribed sanjivani when Lakshmana became unconscious?

Question: This is a question about Ramayana. In the battle between Rama and Ravana, Lakshmana was struck with an arrow shot by Meghnad, the son of Ravana. Lakshmana became unconscious. Which healer was then called by Rama ?
Answer: Sushena, a monkey physician tested Lakshmana when he was hit by a shakti by Ravana (not Meghanad. It is according to Ramcharitmanas, Lakshmana was hit by Mefhnad).
When Sri Rama was worried and heart broken that Lakshmana was hit by Ravana, he laments and gets ready to die like his brother (Sri Rama thought Lakshmana died). Then Sushena, the physician of Vanaras said these comfortable words to Rama.
From Yuddha Kanda Sarga 101 of Valmiki Ramayana,

राममेवं ब्रुवाणं तु शोकव्याकुलितेन्द्रियम् || ६-१०१-२४
  आश्वासयन्नुवाचेदं सुषेणः परमं वचः |
Comforting Rama, whose mind was full of grief and who was thus lamenting, Sushena, for his part, addressed the following excellent words:
नैव पञ्चत्वमापन्नो लक्ष्मणो लक्ष्मिवर्धनः || ६-१०१-२६
  न ह्य्स्य विकृतं वक्त्रं न च श्यामत्वमागतम् |
"Lakshmana, the augmenter of prosperity, has not got into death. His countenance is not changed, nor has it become dark."
His face may be seen with a good brightness and very much placid. The palms of his hands are resembling the petals of a lotus. His eyes too are very bright."

He is the one who prescribed the life bringing herbs and asked Hanuman to bring them quickly. He gives different herbs names for different purposes. But Hanuman could not identify those precious herbs. So, he uprooted the whole Oushadhi mountain and restored it back to its original position after the mission is over.
Hanuman brought the mountain twice. He also brought them once to bring back the lives of dead and wounded Vanaras. The first instance is when the most of the Vanaras including Rama and Lakshmana fell unconscious due to the effect of Brahmastra shot by Indrajeet. Then Jambavan prescribes it and asks Hanuman to bring the herbs because the physician Suṣeṇa was also unconscious. This is said in Sarga 74 of Valmiki Ramayana.
So, for the first time when whole army fell down, it was Jambavan who prescribed. When Lakshmana alone fell unconscious, it was Sushena, the physician.

According to Ramcharitmanas, a fierce battle took place between Lakshmana and Indrajit. Indrajit throws a javelin into the chest of Lakshmana. He was wounded severely and fell unconscious. Jambavan says to bring Sushena and Sushena prescribes Sanjivani.

Jåmbavån  said, Suṣeṇa,  the  physician,  lives  in  Lankå;  someone  should  be sent  to  fetch  him  here. Assuming  a  minute  (indiscernible)  form  Hanumån  went  and immediately  brought  him,  house  and  all. Doha 54 Chaupai 4
rāmapadārabinda sira nāyau āyi suśena |
   kahānāmagiri auṣadhī  jāhu pavānāsuta lenā
Suṣeṇa  came  and  bowed  his  head  at Lord  Råma's  lotus-feet.  He  mentioned  the name of the herb as well as of the mountain where it could be had, and said, "Proceed, O  son  of  the  wind-god,  to  bring  it. Doha 55

So, It is Sushena in Ramcharitmanas also. But he is not said as Vanara.
Answer: Sanjeevani was prescribed by Jambavan, see the reference below about the conversation between Jambavan and Hanuman:

Thereafter, that Jambavan of great splendour spoke to Hanuma as
  follows: "Come on, O foremost of monkeys! You ought to protect the
  lives of monkeys."
"O Hanuma! You ought to go to Himalaya, the foremost of mountains, by
  traveling higher and higher over the large ocean."
"O annihilator of enemies! Thereafter, you will see there the Mount
  Rishabha, the excellent mountain and the very much powerful peak of
  Kailasa, with a golden hue."
"O foremost of monkeys! Sprouted on the head of that mountain, are
  four blazing herbs. You can see them, illuminating the ten quarters."
"You can see there, Mrita Sanjivani (capable of restoring the dead to
  life), Vishalyakarani (capable of extracting weapons and healing all
  wounds inflicted by weapons), Suvarnakarani (restoring the body to its
  original complexion) and Sandhani, the great herb (capable of joining
  severed limbs or fractured bone)."
Comment: This is the first time. Lakshmana was hit by Ravana and it is second time. This time it is Sushena not jambavan
Comment: I agree but when you know what to get and from where to get, next time something happens anyone can recall what was done in the first case, hence credit should be given to the first person. This is what I feel.
Comment: The question is asking for the second time not the first time. No, it is Sushena for the second time. Even for the second time, Hanuman didn't know where the herbs are. So, he brought the total mountain.


Why would an answer posted by a 5 year user end up in the Late Answer New User queue?

Question: I just reviewed this answer. After suggesting minor improvements, my curiosity got the better of me and I checked the profile of the poster and discovered they have been a (granted mostly inactive) member for over 5 years! Is the queue misnamed? Should it be the Late Answer Low Rep queue?
Comment: [Link to Review Queue](https://askubuntu.com/review/late-answers/656834) entry, if anybody's interested.
Answer: I think the "new" refers to rep, and has nothing to do with how long a user has been a member. I don't know how the actual algorithm works, but I assume it's something along the lines of if rep < N && isAnswerToOldQuestion; then.... Or, perhaps, if numberOfAnswers < N; then ....
So I wouldn't be surprised to find answers by users who've been here for years appear in the queue. Not if they haven't answered much before.
Comment: I would assume this to be an accurate assessment. Absent the actual algorithm it's hard to surmise much more. It does seem something of a misnomer though. Perhaps if I'd been more curious I'd have noticed this before. I was surprised to not find an answer on this topic already here.
Answer: I signed up here over two years ago and at the time made a few posts but knew very little of how the AU interface worked or what the "UbuntuQuette" was in AU.
It wasn't until four months ago (after I bricked Windows 7) that I reinstalled Ubuntu and came back to AU. Through the process of resolving 14.04 laptop upgrade to 16.04 glitches I got very keen on learning new things and started answering questions.
So yes, I would say a "new user" has nothing to do with sign-up date but more so on rep points and more specifically learning the etiquette of properly formatted Questions, Answers and Comments.
Comment: Oh you are 100% correct... however the truth such as "You are a low rep user" doesn't sound so hot...LOL
Comment: I think sometimes people just let stress get the best of them and perhaps speak "in the moment". After all we're only human (not Vulcan) so we can't be completely logical all the time (as much as we may strive to be). My viewpoint is that you never know who might have the potential to become a fantastic member of the team and encouragement goes a lot farther than belittlement. I don't think I'm alone in appreciating the former and no one should have to put up with the latter. I don't think wages necessarily equate to ego but It likely has an impact.
Comment: I still think it's a bit of a misnomer...
Comment: I guess your right. That wouldn't "Be nice!"
Comment: Speaking of "nice" I think almost all the high rep users around here are nice and not at all condescending to "new users"
Comment: I would tend to agree with the "almost all" statement. It's been a couple years at least since I made that accusation (It wasn't nice but it was well deserved at the time)
Comment: I imagine most of the egotistical techies are on Windows Support Forums and making +100k / year feeling they don' t have the time for newbies or people who don't "rtfm".
Comment: Well said my friend.


Why do astronauts move so slowly in zero gravity?

Question: When astronauts are floating about in a spaceship or space station, they nearly always move very slowly. After doing a bit of research I can't see why being in zero gravity would restrict movement to such a degree. It's almost as if there's resistance to their movement, like they're moving through water.
Comment: I'm voting to close this question as off-topic because this does not have anything to do with astronomy.
Comment: This is mostly a question about [movies.se] and partly a question about [space.se], but it seems to have nothing at all to do with astronomy.
Comment: I think it could be re-worded to be more about space exploration, like, how people would move once they got acquainted with zero g or asking how fast astronauts move.    I've seen videos of them moving pretty fast in orbit.
Comment: always move slowly? [not always](https://www.youtube.com/watch?v=LB71-QJMgxQ) though it looks pretty slow as it's a large space.
Answer: It's more for safety than anything else. Space is a very dangerous place for so many reasons. And making mistakes can very easily cause death.
Being weightless does not mean you lose mass, so momentum is just as difficult as ever. But whereas on the ground you can easily use friction to stop, in space if you try to stop against the floor you will just move off it. You can only stop by holding something, or pressing against something close to perpendicular to your movement.
As an example, imagine you jumped with all your force from one wall in the ISS. You will notice as you approach the other end that you are travelling at speed, head first, with no safe way to stop. Even reaching out to a handhold on a side wall will whip you round and into that wall, possibly injuring yourself or damaging instruments on the wall.
Look at any video from the ISS to see how carefully they move.
Similarly, outside the ISS, you want to do everything slowly so you don't damage your suit, miss a handhold or otherwise cause death.
Comment: @Clockwork An astronaut wearing one of the suits used on the space shuttle, including the life-support backpack, weighed about 500lbs, which is about a quarter of a ton, not "several tons". (Source: [NASA](https://spaceflight.nasa.gov/outreach/SignificantIncidentsEVA/assets/space_suit_evolution.pdf); see page 4 of the PDF.)
Comment: This reminds me of the way some people commented the movie Gravity. Some characters were moving at relatively high speed in their suit, and tried to grab something to stop themselves. The people commented how they should have lost their arm, considering they were weighing several tons with the suit.
Comment: @DavidRicherby Well, guess my memory (and my lack of knowledge on the matter) tricked me. Still, a quarter of a ton still sounds heavy for a human-being to throw themself without getting crushed on impact.
Answer: Creating the illusion of weightlessness in movies actually requires a LOT of people operating cranes with harnesses and wires to hold the actors suspended in air. It's not easy moving (nor safe) the equipment holding the actors about as fast as real astronauts are able to move on the ISS. Also, it's important to not let the cranes and their crews fall into the view of the camera. As a result, there's quite a lot of choreography that goes into setting up weightless scenes, deciding the best camera angles, moving the actors, rehearsals, etc. All those factors go into slowing down the action we see in movies. Surprisingly, the wires are easier to hide either because their coloring and thickness are taken advantage of which causes them to be naturally hidden by the film's resolution in older movies, or they can be digitally masked out in post-production if needed in modern films.
Mind you, astronauts don't fly about helterskelter on the ISS! They're being very careful, there, too. But moving about the station only needs a very slight push off a wall and the same force to stop them when they get to where they want to be in very short time. But while they're flying between, they'll frequently entertain themselves doing stunts in zeroG such as flips and twists.
Answer: There is no air resistance in space. So if you increment your own speed you'll continue with that speed until you crash (considering the laws of thermodynamics).
For safety, you should move slowly.
Comment: I think the question is more about insides of space ships etc, with atmosphere, and not vacuum of space.
Comment: Spacecraft are surprisingly fragile, but they move pretty darned quickly in the vacuum of space.


2007 Honda Civic p0843 high error code. Replaced switch, no change. Won't shift into 4th

Question: I am stumped with a 2007 Honda Civic 1.8 sedan with automatic transmission.  Other the car failing to shift into 4th gear all other transmissions functions are fine.  It has a trans error code (p0843 high) indicating a failing pressure switch.  Replaced the switch and it did bot correct the problem. I tested the voltage to the terminal that connects to the switch and did have a good ground with 5 -volts
Comment: 5v on the ground?
Answer: If you replaced the switch and you still get the code then you probably have a plugged up line. This would keep the switch from seeing the expected pressure.
This might be fixable with a flush and fill or if you can pull the switch and inspect inside the hole you may be able to see the plug and extract it.
When was your trans fluid changed last?