Two (sometimes three) cymbals, one placed on top of the other, so as to produce a different sound than either would produce alone. Splashes and China Kangs are usually used.

A stack is a term used in Ultimate Frisbee to refer to a line of offensive players. A stack gives some structure to the offense, and prevents picks and clogging. Clogging is what happens when one player is standing in the space another player needs to run into to get open and get the disc. A stack is usually in the middle of the field, with the players in single file parallel to the sidelines. The stack should probably be about 15 yards from the disc, and there should be a few yards between each player in the stack. Players make cuts out of the stack and "clear out" by running back into the stack after making a cut.

The stack developed in Ultimate Frisbee to open up space for cutters(players who are trying to get open and get thrown the disc) and avoid picks, which are illegal in Ultimate. By keeping players who are not cutting out of the area that the cutter is cutting towards, it reduces the chances that the cutter's defender will get picked, and gives the cutter more room to run in and get open.

o's are offense, x's are defense. Capital O has the disc.
|-------------------------------------------------------|
|							|
|							|
|							|
|							|
|							|
|-------------------------------------------------------|
|							|
|							|
|			   Ox				|
|							|
|							|
|							|
|							|
|							|
|	SPACE		x  o		SPACE		|
|			x  o				|
|			x  o				|
|			x  o				|
|			x  o				|
|			x  o				|
|							|
|							|
|							|
|							|
|							|
|							|
|							|
|							|
|-------------------------------------------------------|
|							|
|							|
|							|
|							|
|							|
|							|
|							|
|-------------------------------------------------------|
See the space that is open on both sides of the stack? The next step exceeds my ASCII art skills, but imagine that the offensive players can now run out of the stack into the SPACE, where they can get open and catch the disc. If everyone was just running around, there would be no space to run into and no one would be able to get open. Also, it's important to clear out once you've cut into a space, because once you're there, it's no longer space that can be cut into. So once a player has cut into the space, he needs to run back into the stack. As that player is clearing out, another player should be starting to cut into the space that the first player is now clearing out of. This cycle should continue, with one player cutting, clearing, and another player cutting into the space continuously. This should be moving the disc downfield, and the stack should move with the disc, always keeping approximately 15 yards in between the disc and the front of the stack.

That's the basic idea of the stack. There's a number of other basic concepts that are important in a basic offense, namely the dump. Also, the stack is a more abstract idea than this writeup would lead you to believe. Stacks are not just vertical lines of players in the middle of the field. There are offenses that rely on horizontal and diagonal stacks, and the stack itself needs to change and adapt to the playing conditions and the particular offense. Sometimes the stack needs to be farther back, i.e. if you were running a handler weave, or closer, if you want to make it easier to make deep cuts. If you want more information, you should look at http://www.ultimatehandbook.com, which is an excellent site with lots of good information for Ultimate players of all levels.

Side note:

Interestingly enough, now that I think about it, the stack(in Ultimate) is not a stack(a LIFO data structure). It's actually a queue, since the last person to clear into the stack should wait until the other players have cut to make another cut, which is LILO behaviour.
squirrelcide = S = stack puke

stack n.

The set of things a person has to do in the future. One speaks of the next project to be attacked as having risen to the top of the stack. "I'm afraid I've got real work to do, so this'll have to be pushed way down on my stack." "I haven't done it yet because every time I pop my stack something new gets pushed." If you are interrupted several times in the middle of a conversation, "My stack overflowed" means "I forget what we were talking about." The implication is that more items were pushed onto the stack than could be remembered, so the least recent items were lost. The usual physical example of a stack is to be found in a cafeteria: a pile of plates or trays sitting on a spring in a well, so that when you put one on the top they all sink down, and when you take one off the top the rest spring up a bit. See also push and pop.

At MIT, PDL used to be a more common synonym for stack in all these contexts, and this may still be true. Everywhere else stack seems to be the preferred term. Knuth ("The Art of Computer Programming", second edition, vol. 1, p. 236) says:

Many people who realized the importance of stacks and queues independently have given other names to these structures: stacks have been called push-down lists, reversion storages, cellars, nesting stores, piles, last-in-first-out ("LIFO") lists, and even yo-yo lists!

--The Jargon File version 4.3.1, ed. ESR, autonoded by rescdsk.

One of the basic, canonical data structures.

Logically resembling a stack of items, you can only affect the top. Putting another object on, taking it off, or viewing it.

(Some purists may argue that viewing the top object is not part of the traditional stack data structure, but I would say that it is enough used in practice that it may as well be.)

Common user interface:

Uses include:

A stack, in the world of guitars, consists of an amplifier head and two speaker cabinets that are stacked on one another. This arrangement is most likely where the name “stack” came from. The speaker cabinets within a stack usually contain four twelve inch speakers in a square arrangement and the head is typically around 100watts.When these components are all on top of each other they form quite a large and intimidating wall of musical amplification that is desired by many guitarists.

One of the most famous makers of stacks is Marshall Amplification; however, almost all amplifier manufacturers produce a stack in one form or another.

No code here? Come on people! I can offer up my Java implementation of a Stack, which is based on the Doubly Linked List (which I have also noded). This should help anyone struggling along (like I was) in a Data Structures class. Even if you aren't using Java, the code is well commented for easy porting to other languages. Note: this Stack takes objects; not primitive types. Enjoy!

//************************************************************
// This class defnines the Stack structure.
// It is based on a Linked List.
//************************************************************

public class MyStack extends ListClass
{

//************************************************************
// Declares an integer to hold the number of elements on the
// stack.
//************************************************************

	private int numOnStack = 0;

//************************************************************
// This is the default constructor for the stack class.
// It assigns all omnipresent nodes to null.
//************************************************************

	public MyStack()
	{
	start = current = end = null;
	}

//************************************************************
// This method, push() takes an object and adds it to the 
// stack. It also increments numOnStack.
//************************************************************

	public void push(Object oneObject)
	{
		addBefore(oneObject);
		numOnStack++;
	}

//************************************************************
// This method, pop() removes the top element from the stack
// and returns the contents to the calling object. It also
// decrements numOnStack.
//************************************************************

	public Object pop()
	{
		
		Object o = null;
		current = start;

		if(this.isEmpty() == false)
		{
			if(start.getNext() == null)
			{
				o = start.getObject();
				current = start = end = null;
				numOnStack--;
				return(o);
			}
			else
			{
				o = start.getObject();
				start = current = start.getNext();
				numOnStack--;
				return(o);
			}
		}
		return("If you see this, there is an error.");
	}

//************************************************************
// This method, getNumOnStack() returns the number of
// elements on the stack.
//************************************************************

	public int getNumOnStack()
	{
	return numOnStack;
	}

//************************************************************
// This method, isEmpty() determines if the stack is empty,
// using the int value of numOnStack as an indicator.
//************************************************************

	public boolean isEmpty()
	{
		if(numOnStack == 0)
			return true;
		else
			return false;
	}
}

Stack (?), a. [Icel. stakkr; akin to Sw. stack, Dan. stak. Sf. Stake.]

1.

A large pile of hay, grain, straw, or the like, usually of a nearly conical form, but sometimes rectangular or oblong, contracted at the top to a point or ridge, and sometimes covered with thatch.

But corn was housed, and beans were in the stack. Cowper.

2.

A pile of poles or wood, indefinite in quantity.

Against every pillar was a stack of billets above a man's height. Bacon.

3.

A pile of wood containing 108 cubic feet.

[Eng.]

4. Arch. (a)

A number of flues embodied in one structure, rising above the roof. Hence:

(b)

Any single insulated and prominent structure, or upright pipe, which affords a conduit for smoke; as, the brick smokestack of a factory; the smokestack of a steam vessel.

<-- Computer programming (a)

A section of memory in a computer used for temporary storage of data, in which the last datum stored is the first retrieved

. (b)

A data structure within random-access memory used to simulate a hardware stack, as, a push-down stack

. -->

Stack of arms Mil., a number of muskets or rifles set up together, with the bayonets crossing one another, forming a sort of conical self-supporting pile.

 

© Webster 1913.


Stack, v. t. [imp. & p. p. Stacked (?); p. pr. & vb. n. Stacking.] [Cf. Sw. stacka, Dan. stakke. See Stack, n.]

To lay in a conical or other pile; to make into a large pile; as, to stack hay, cornstalks, or grain; to stack or place wood.

To stack arms Mil., to set up a number of muskets or rifles together, with the bayonets crossing one another, and forming a sort of conical pile.

 

© Webster 1913.

Log in or registerto write something here or to contact authors.