text:
'Terminator 5′ Looks to Add 'Spider-Man' Star J.K. Simmons
'Terminator 5,' which has the subtitle 'Genesis,' is going to have the sticky problem of trying to reboot the franchise to start a new trilogy, while also interweaving material from the original four films (though likely it will stick closer to the first film, with nods to some of the sequels) on top of bringing back Arnold Schwarzenegger in some capacity. To help provide the duct tape to make this possible, the film is looking to recruit J.K. Simmons to play a very important role.
According to The Hollywood Reporter, Simmons would play an alcoholic detective, who's been following the case of Sarah Connor and the robots who try to kill her since 1984 (the year the first film was released). As this new film's Sarah Connor is played by Emilia Clarke (who's currently 26) and her son John Connor is played by Jason Clarke (no relation, who's 44), and Simmons has been following this case for thirty years, well, that opens so many possible time traveling doors, we don't know which one to knock on.
But this also makes it sound exciting if they are embracing the chaos of time travel, perhaps invoking the parallel realities that have happened in films like 'Back to the Future II' and 'Primer.' 'Terminator: Genesis' is scheduled to hit theaters July 1, 2015

subset: commoncrawl


text:
With a new White House push to promote the Affordable Care Act well underway, the question is whether an improved HealthCare.gov site and onslaught of positive talking points will be enough to bolster Senate Democrats facing tough races in 2014.
One re-election fight to watch is Democratic Sen. Jeanne Shaheen's in New Hampshire, where she's been taking heat for supporting the new health care law.
Step inside a small diner called Chez Vachon in a working-class section of Manchester, N.H., and you'd never guess the White House is actually regaining its footing on the health care rollout. The president is reporting promising enrollment numbers and a faster website, but John Hill couldn't care less. He says the price of his insurance has skyrocketed.
"We asked why the price of the insurance was so high," says Hill. "They said, 'Well, the new Obamacare law. That's the reason why.' "
That law had some pretty severe repercussions in New Hampshire. A strong Tea Party faction in the state legislature voted down a state health insurance exchange, so everyone in the state applying for insurance under the Affordable Care Act has to sign up on the federal government website.
But that federal exchange has drawn only one insurance provider for New Hampshire: Anthem Blue Cross and Blue Shield. And Anthem shut out 10 of the state's 26 hospitals from its health plans on the exchange, which means traveling in a car for an hour or more for many people in northern New Hampshire who need to see a doctor.
Hill says he's absolutely not voting for Shaheen next year.
"She voted for this. She knew what she was getting into," says Hill. "Now she realizes, 'Oh, this is a big mistake.' "
Shaheen was one of most vocal Democrats to criticize the launch of HealthCare.gov. She's demanded an extension of the enrollment period, and asked President Obama to appoint someone to oversee website fixes into next year.
Theresa Avard says Shaheen's just trying to have it both ways by distancing herself from a law that so many people in New Hampshire hate.
"You can't be a yo-yo," says Avard. "I'm sorry, you know. That's what I call my grandchildren when they don't do right. They yo-yo, up and down."
But Shaheen rejects the suggestion that she's just protecting herself for the next election cycle.
"This should not be about politics. This should be about good policy," says Shaheen. "I've been working on health care issues since I first was elected to the state senate from the seacoast of New Hampshire over 20 years ago."
On this day, she's touring the National Visa Center in Portsmouth to draw attention to a program granting visas for Iraqis and Afghans who risked their lives working for the U.S. Since the rollout of the new health care law, Shaheen hasn't hosted any town hall meetings. But she says her office has been inundated with angry complaints from people upset about the launch.
Still, Shaheen says: "It's a long time from now to [November of] 2014. And I think we're going to get the problems fixed with the health care law.
"I think there will probably be other things that come up, just as there are when we're making that significant of policy change," says Shaheen. "But the way to deal with it [is] to find those fixes."
Toppling Shaheen in 2014 is going to take a formidable force. She was a popular three-term governor who's still enjoying pretty solid poll numbers.
"For Shaheen, right now, Obamacare is the only cloud in the sky in New Hampshire," says Dante Scala, a political scientist at the University of New Hampshire. "So what she needs to do is just keep guard and not become complacent with what is clearly a winning position at this point."
Former Sen. Scott Brown of Massachusetts keeps flirting with the idea of running against her, and he has the star power, but he still won't commit.
Bob Smith, a former U.S. senator, has announced his candidacy, but he still needs to move back to New Hampshire from Florida, where he failed twice to win a Senate seat. And the other Republican candidates just don't have much name recognition.
As split as New Hampshire is over the health care law, it's a big question whether people are going to be focusing on other things by next fall.
Back at Chez Vachon, Bob Garon says Republicans need to give up on their obsession with the Affordable Care Act.
"I really don't think that we are going to elect a politician because of Obamacare," says Garon. "I think what's going to sink in is it's the law — whether you like it or not. You can bounce it around and play tennis with it all you want, but it's the damn law."
But the New Hampshire state Republican Party says it plans to make Obamacare a central issue next fall.
"There's no question that what voters care about right now is the collapse of Obamacare — the failed rollout, the increased costs, the decreased access to quality health insurance," says Jennifer Horn, chair of the New Hampshire Republican Party. "So absolutely that is something we will be talking about."
Copyright 2023 NPR. To see more, visit https://www.npr.org.


text:
Book of Tehillim (Psalms): Chapter 80
80:1 Give ear, O Shepherd of Israel, thou that leadest Joseph like a flock; thou that dwellest between the cherubims, shine forth.
80:2 Before Ephraim and Benjamin and Manasseh stir up thy strength, and come and save us.
80:3 Turn us again, O God, and cause thy face to shine; and we shall be saved.
80:4 O LORD God of hosts, how long wilt thou be angry against the prayer of thy people?
80:5 Thou feedest them with the bread of tears; and givest them tears to drink in great measure.
80:6 Thou makest us a strife unto our neighbours: and our enemies laugh among themselves.
80:7 Turn us again, O God of hosts, and cause thy face to shine; and we shall be saved.
80:8 Thou hast brought a vine out of Egypt: thou hast cast out the heathen, and planted it.
80:9 Thou preparedst room before it, and didst cause it to take deep root, and it filled the land.
80:10 The hills were covered with the shadow of it, and the boughs thereof were like the goodly cedars.
80:11 She sent out her boughs unto the sea, and her branches unto the river.
80:12 Why hast thou then broken down her hedges, so that all they which pass by the way do pluck her?
80:13 The boar out of the wood doth waste it, and the wild beast of the field doth devour it.
80:14 Return, we beseech thee, O God of hosts: look down from heaven, and behold, and visit this vine;
80:15 And the vineyard which thy right hand hath planted, and the branch that thou madest strong for thyself.
80:16 It is burned with fire, it is cut down: they perish at the rebuke of thy countenance.
80:17 Let thy hand be upon the man of thy right hand, upon the son of man whom thou madest strong for thyself.
80:18 So will not we go back from thee: quicken us, and we will call upon thy name.
80:19 Turn us again, O LORD God of hosts, cause thy face to shine; and we shall be saved.
Sources: Portions copyright © 1997 by Benyamin Pilant, All Rights Reserved
JPS Electronic Edition Copyright © 1998 by Larry Nelson, All Rights Reserved
Jewish Bible


text:
Concurrent Programming in Java: Creating Threads
new Thread(aRunnable).start();
Is this a fancy way to invoke a method (i.e., a Runnable's run method), or is it a way to create a fancy object (i.e., a new instance of class Thread)? Clearly it is both, but focusing on one aspect versus the other leads to two approaches to using threads that were implicit in discussions in Chapter 1:
Task-based. Here, the main reason to use a thread is to asynchronously invoke a method that performs some task. The task might range from a single method to an entire session. Thread-based techniques can support message-passing schemes that escape the limitations of pure procedural calls. Task-based designs are seen in event frameworks, parallel computation, and IO-intensive systems.
Actor-based. Here, the main reason to use a thread is to create and set into motion a new autonomous, active, process-like object. This object may in turn react to external events, interact with other actors, and so on. Actor-based designs are seen in reactive, control, and distributed systems. They are also the focus of most formal approaches to concurrency.
(Both the terms task and actor have many overloaded meanings and near-synonyms. We'll confine usage to the above senses.)
In task-based systems, passive objects sometimes send active (thread-propelled) messages, while in actor-based systems, active objects normally send passive messages. As is usually the case for artificial dichotomies, neither approach is always best, and there is a huge middle ground that can be designed from either or both perspectives.
Actor-based approaches are commonly used in the construction of daemons that interact with other systems. They are also employed when defining intrinsically active entities, for example the GamePlayer in 3.2.4. Their main methods often take a reactive looping form:
for(;;) { acceptAndProcessCommand(); }
Task-based approaches are commonly used when there is some conceptual or performance-based reason to execute a given task, service, or computation asynchronously rather than relying on direct procedural invocation. Task-based designs provide a separation of concerns between logical asynchrony and mappings to threads and thread-based constructions. They receive the bulk of discussion in this chapter.
As an initial example, here is one way to approach a common thread-based design, a web service. Here, a running WebService is a "daemon process" actor-style thread — it continuously interacts with its environment by listening for new incoming requests. But invocations to handler.process are issued in a task-based manner — a new task is set in motion to handle each incoming request. Here, for the sake of concise illustration, the request is simply a number, and the handler just returns the negation of the number back to the client.
class WebService implements Runnable { static final int PORT = 1040; // just for demo Handler handler = new Handler(); public void run() { try { ServerSocket socket = new ServerSocket(PORT); for (;;) { final Socket connection = socket.accept(); new Thread(new Runnable() { public void run() { handler.process(connection); }}).start(); } } catch(Exception e) { } // die } public static void main(String[ ] args) { new Thread(new WebService()).start(); } }class Handler { void process(Socket s) { DataInputStream in = null; DataOutputStream out = null; try { in = new DataInputStream(s.getInputStream()); out = new DataOutputStream(s.getOutputStream()); int request = in.readInt(); int result = -request; // return negation to client out.writeInt(result); } catch(IOException ex) {} // fall through finally { // clean up try { if (in != null) in.close(); } catch (IOException ignore) {} try { if (out != null) out.close(); } catch (IOException ignore) {} try { s.close(); } catch (IOException ignore) {} } } }
This chapter divides coverage of thread construction and structuring techniques as follows:
4.1 presents a series of options for implementing conceptually oneway messages, sometimes by asynchronously initiating tasks using threads or thread-based lightweight execution frameworks.
4.2 discusses the design of systems in which networks of components employ oneway messaging strategies.
4.3 presents alternatives for constructing threads that compute results or provide services to clients that initiate them.
4.4 examines problem decomposition techniques that can be used to improve performance by exploiting multiprocessors.
4.5 provides an overview of constructs and frameworks for designing systems of active objects, illustrated in part using CSP.
Many of the designs presented in this chapter straddle the borders among concurrent, distributed, and parallel programming. Presentations focus on concurrent, single-JVM solutions. But they include constructions often seen when developing the plumbing support for systems and frameworks involving multiple processes or computers.
4.1 Oneway Messages
A host object issues a logically oneway message to one or more recipients without depending on the consequences of that message. Sending a oneway message somehow results in some task being performed. The task might consist of only a single line of code, or might represent a session that entails acquisition of many resources and hours of computation. But the outcome of the thread issuing a oneway message does not rely on the task's outcome, or on when the task completes, or (normally) on whether it ever completes. Common examples include:
Events |
Mouse clicks, etc. |
Notifications |
Status change alerts |
Postings |
Mail messages, stock quotes, etc. |
Activations |
Creating Applets, daemons, etc. |
Commands |
Print requests, etc. |
Relays |
Message forwardings and dispatchings |
Oneway interactions between senders and recipients need not be strictly asynchronous. For example, the sender may be responsible for ensuring that a recipient actually receives the message. Also, the sender or another object may later wish to cancel or roll back the effects of the resulting task (which is of course not always possible, for example if the task has already completed — see 3.1.2).
If every task could run instantaneously, you might trigger oneway messages via procedural invocations in which the caller waits out the task triggered by the message, even though it has no reason to do so. But there are often performance-based, conceptual, and logistical reasons to issue some of these messages via thread-based constructions in which the associated tasks proceed independently.
4.1.1 Message Formats
Many different styles of invocation are encompassed under the notion of oneway message passing. While some of them are more closely associated with distributed or multiprocess applications (see 1.2.2), any of them can be used in conjunction with the constructions discussed in this section. In addition to direct method invocations, message formats may include:
Command strings. The recipient must parse, decode, and then dispatch the associated task. Command string messages are widely used in socket-based and pipe-based communication, especially in web services.
Event objects. The message contains a structured description of an event. The recipient then dispatches some arbitrary handling task that it associates with the event. Event objects are used extensively in GUI frameworks such as java.awt, as well as component frameworks supported by java.beans.
Request objects. The message contains an encoding of a method name and (marshalled or serialized) arguments. The recipient issues the corresponding method call to a helper object that performs this method. Request objects are used in distributed object support systems such as those in java.rmi and org.omg.corba. Variants are used in Ada tasking.
Class objects. The message is a representation of a class (for example via a .class file) which the recipient then instantiates. This scheme is used in the java.applet framework, as well as in remote activation protocols.
Runnable objects. The message consists of some code that the recipient executes. Mixed forms of runnable events (which include both an event description and an associated action) are used in some event frameworks. Extended forms employing serialized runnable objects are seen in mobile agent frameworks.
Arbitrary objects. A sender may treat any kind of object as a message by including it as method argument or passing it through a Channel (see 4.2.1). For example, in the JavaSpaces™ framework, senders may post any serialized object as a message (also known as an entry). Recipients accept only those entries with types and field values that conform to a specified set of matching criteria. Recipients then process these objects in any appropriate manner.
Differences among these formats reflect (among other things) how much the caller knows about the code the recipient needs to run to perform its task. It is often both most convenient and most efficient to use runnable objects, especially in thread-based frameworks that use instances of class Runnable as arguments in Thread constructors. We'll focus on this form, but occasionally illustrate others.
4.1.2 Open Calls
Consider the central Host object in a call chain in which the Host receives req requests from any number of Clients and, in the course of processing them, must issue logically oneway handle messages to one or more Helper objects. Again, we'll ignore the facts that an arbitrary amount of effort might be needed to decode the request before acting upon it, that the request might actually be read from a socket as seen in the WebService class, and so on. Also, all classes discussed in this section can be extended to issue multicasts to multiple helpers using the constructions described in 2.4.4 and 3.5.2.
The main design force here is latency. If a Host is busy servicing requests, then it cannot accept new ones. This adds response time to new requests from Clients, reducing overall service availability.
Some aspects of latency can be addressed simply by using the pass-through and open call designs described in 2.4:
class OpenCallHost { // Generic code sketch protected long localState; protected final Helper helper = new Helper(); protected synchronized void updateState(...) { localState = ...; } public void req(...) { updateState(...); helper.handle(...); } }
Here, even if the helper.handle call is relatively time-consuming, the Host object will still be able to accept new requests from clients running in different threads. The request acceptance rate is bounded only by the time it takes to update local state.
The use of open calls typically eliminates bottleneck points surrounding a given Host, but does not address the broader question of how to introduce concurrency into a system to begin with. Open calls are useful only when clients somehow already know enough to use some other approach that permits independent execution when necessary or desired.
4.1.3 Thread-Per-Message
Concurrency can be introduced into oneway messaging designs by issuing a message in its own thread, as in:
class ThreadPerMessageHost { // Generic code sketch protected long localState; protected final Helper helper = new Helper(); protected synchronized void updateState() { localState = ...; } public void req(...) { updateState(...); new Thread(new Runnable() { public void run() { helper.handle(...); } }).start(); } }
This strategy improves throughput when multiple parallel tasks can run faster than a sequence of them could, normally because they are either IO-bound or are compute-bound and running on a multiprocessor. It can also enhance fairness and improve availability if clients need not wait for each other's tasks to complete.
Decisions about whether to create and start threads to perform tasks are not too different from decisions about whether to create other kinds of objects or send other kinds of messages: The benefits must outweigh the costs.
Thread-per-message designs introduce response latency because thread creation is more expensive than direct method invocation. When tasks are time-consuming compared to thread construction time, are session-based, need to be isolated from other independent activities, or can exploit IO or CPU parallelism, the trade-offs are generally worth it. But performance problems can emerge even when construction latencies are acceptable. The JVM implementation and/or operating system may not respond well to the construction of too many threads. For example, they may run out of system resources associated with threads. Also, as the number of threads increases, thread scheduling and context switching overhead can overwhelm processing times.
126.96.36.199 Executors
The coding style seen in class ThreadPerMessage can become a problem because of its direct reliance on class Thread. Such usages can make it more difficult to adjust thread initialization parameters, as well as thread-specific data (see 2.3.2) used across an application. This can be avoided by creating an interface, say:
interface Executor { void execute(Runnable r); }
This interface can be implemented with classes such as:
class PlainThreadExecutor implements Executor { public void execute(Runnable r) { new Thread(r).start(); } }
These implementations may be used in classes such as:
class HostWithExecutor { // Generic code sketch protected long localState; protected final Helper helper = new Helper(); protected final Executor executor; public HostWithExecutor(Executor e) { executor = e; } protected synchronized void updateState(...) { localState = ...; } public void req(...) { updateState(...); executor.execute(new Runnable() { public void run() { helper.handle(...); } }); } }
The use of such interfaces also permits replacement of threads with lightweight executable frameworks.
4.1.4 Worker Threads
Lightweight executable frameworks fill the gap between open calls and thread-per-message designs. They apply when you need to introduce limited concurrency, at the expense of some usage restrictions, in order to maximize (or at least improve) throughput and minimize average latencies.
Lightweight executable frameworks can be constructed in many ways, but all stem from the basic idea of using one thread to execute many unrelated tasks (here, in succession). These threads are known as worker threads, background threads, and as thread pools when more than one thread is used.
Each worker continually accepts new Runnable commands from hosts and holds them in some kind of Channel (a queue, buffer, etc. — see 3.4.1) until they can be run. This design has the classic form of a producer-consumer relationship: the host produces tasks and workers consume them by running them.
Lightweight executable frameworks can improve the structure of some task-based concurrent programs, by allowing you to package many smaller, logically asynchronous units of execution as tasks without having to worry much about performance consequences: Entering a Runnable into a queue is likely to be faster than creating a new Thread object. And because you can control the number of worker threads, you can minimize chances of resource exhaustion and reduce context-switching overhead. Explicit queuing also permits greater flexibility in tuning execution semantics. For example, you can implement Channels as priority queues that order tasks with more deterministic control than is guaranteed by Thread.setPriority. (See 4.3.4 for an example.)
To interoperate with pure thread-based versions, worker threads can be packaged as Executors. Here is a generic implementation that could be used in the HostWithExecutor class instead of the thread-per-message version:
class PlainWorkerPool implements Executor { protected final Channel workQueue; public void execute(Runnable r) { try { workQueue.put(r); } catch (InterruptedException ie) { // postpone response Thread.currentThread().interrupt(); } } public PlainWorkerPool(Channel ch, int nworkers) { workQueue = ch; for (int i = 0; i < nworkers; ++i) activate(); } protected void activate() { Runnable runLoop = new Runnable() { public void run() { try { for (;;) { Runnable r = (Runnable)(workQueue.take()); r.run(); } } catch (InterruptedException ie) {} // die } }; new Thread(runLoop).start(); } }
188.8.131.52 Design choices
The first decision to make surrounding lightweight executable frameworks based on worker threads is whether to create or use them at all. The main question is whether there is some property of ordinary Threads that you do not need or are willing to give up. If not, it is unlikely that you will arrive at a solution that outperforms the built-in thread support on production JVM implementations.
The trade-offs that obtain the performance advantages of worker threads have several additional tunable parameters, usage consequences, and programming obligations that can impact the design and use of worker thread classes (including those contained in the util.concurrent package available from the online supplement).
Most worker threads must be treated "anonymously". Because the same worker thread is reused for multiple tasks, the use of ThreadLocal and other thread-specific contextual control techniques (see 2.3.2) becomes more awkward. To cope with this, you need to know about all such contextual data, and somehow reset it if necessary upon executing each task. (This includes information about security contexts maintained by run-time support classes.) However, most lightweight executable frameworks avoid any reliance on thread-specific techniques.
If identity is the only property of threads you are willing to give up, then the only potential performance value of worker threads is minimization of start-up overhead by reusing existing threads to execute multiple Runnable tasks, while still possibly bounding resource consumption.
Runnable tasks that are sitting in queues do not run. This is one source of performance benefits in most worker-thread designs — if each action were associated with a thread, it would need to be independently scheduled by the JVM. But as a consequence, queued execution cannot in general be used when there are any dependencies among tasks. If a currently running task blocks waiting for a condition produced by a task still waiting in the queue, the system may freeze up. Options here include:
Use as many worker threads as there are simultaneously executing tasks. In this case, the Channel need not perform any queuing, so you can use SynchronousChannels (see 18.104.22.168), queueless channels that require each put to wait for a take and vice versa. Here, the host objects merely hand off tasks to worker threads, which immediately start executing them. For this to work well, worker thread pools should be dynamically expandable.
Restrict usage to contexts in which task dependencies are impossible, for example in HTTP servers where each message is issued by an unrelated external client requesting a file. Require the helper objects to create actual Threads when they cannot ensure independence.
Create custom queues that understand the dependencies among the particular kinds of tasks being processed by the worker threads. For example, most pools used for processing tasks representing transactions (see 3.6) must keep track of transaction dependencies. And the lightweight parallel framework described in 4.4.1 relies on special queuing policies that apply only to subtasks created in divide-and-conquer algorithms.
As the request rate increases, a worker pool will eventually become saturated. All worker threads will be processing tasks and the Host object(s) using the pool will be unable to hand off work. Possible responses include:
Increase the pool size. In many applications, bounds are heuristic estimates. If a bound is just a guess based on values shown to work well on a particular platform under test workloads, it can be increased. At some point, though, one of the other options must be taken unless you can tolerate failure if the JVM runs out of enough resources to construct a new Thread.
If the nature of the service allows it, use an unbounded buffered channel and let requests pile up. This risks potential system failure due to exhaustion of memory, but this takes longer to happen than does resource exhaustion surrounding Thread construction.
Establish a back-pressure notification scheme to ask clients to stop sending so many requests. If the ultimate clients are part of a distributed system, they may be able to use another server instead.
Drop (discard) new requests upon saturation. This can be a good option if you know that clients will retry anyway. However, unless retries are automatic, you need to add callbacks, events, or notifications back to clients to alert them of the drops so that they will know enough to retry (see 4.3.1).
Make room for the new request by dropping old requests that have been queued but not yet run, or even cancelling one or more executing tasks. This preference for new requests over old ones upon saturation sometimes meshes well with usage patterns. For example, in some telecommunications systems, old unserviced tasks are usually requests by clients that have already given up and disconnected.
Block until some thread is available. This can be a good option when handlers are of predictable, short-lived duration, so you can be confident that the wait will unblock without unacceptable delays.
The Host can run the task directly itself, in its current thread. This is often the best default choice. In essence, the Host momentarily becomes single-threaded. The act of servicing the request limits the rate at which it can accept new requests, thus preventing further local breakdowns.
Thread management
The PlainWorkerPool class is somewhat wasteful because it creates all worker threads upon start-up, whether they are needed or not, and lets them all live on indefinitely, even when the service is not being used. These problems can be alleviated by using a management class that supports:
Lazy construction: Activate a new thread only when a request cannot be serviced immediately by an existing idle thread. Lazy construction allows users to provide large enough pool size limits to avoid underutilization problems occurring when fewer threads are running than a given computer can handle. This comes at the minor expense of occasionally higher latencies when a new request causes a new thread to be created. The start-up effects of lazy construction can be tempered by creating a small number of "warm" threads upon construction of the pool.
Idle time-outs: Allow threads to time out waiting for work and to terminate upon time-out. This eventually causes all workers to exit if the pool is not used for prolonged periods. When coupled with lazy construction, these dead threads will be replaced with new ones if the request rate later increases.
In heavily resource-conscious applications, you may also associate other resources (such as sets of reusable graphical objects) with each worker thread, thus combining resource pools (see 22.214.171.124) with thread pools.
You may need to distinguish cancellation (see 3.1.2) of a task from cancellation of the worker thread performing that task. One approach is:
Upon interruption, allow the current worker thread to die, but replace it if necessary with a fresh worker thread if the work queue is not empty or when a new incoming task arrives.
Provide a shutdown method in the worker thread class that causes existing workers to die and no additional workers to be created.
Additionally, you may need to trigger some kind of error handling if a Host thread is cancelled during a task hand-off. While the silent swallowing of InterruptedException without queuing a task seen in PlainWorkerPool conforms to the minimal requirements of oneway message-passing frameworks, most applications need to take other remedial actions.
126.96.36.199 Event queues
Many event-based frameworks (including the ones supported in the java.awt and javax.swing packages) rely on designs in which exactly one worker thread operates on an unbounded queue. The queue holds instances of EventObject that must be dispatched (as opposed to Runnable objects that self-dispatch), normally to listener objects defined by the application. Often the listeners are the same objects as those that initially generate events.
The use of a single thread operating on a single event queue simplifies usage compared to general worker-thread designs, but also imposes some limitations that are characteristic of event frameworks:
The ordering properties of a queue can be exploited to optimize handling. For example, automatic event-filtering techniques can be used to remove or combine duplicate repaint events for the same screen area before they hit the front of the queue and are taken by the worker thread.
You can require that all methods operating on certain objects be invoked only by issuing events onto the queue, and are thus ultimately performed by the single worker thread. This results in a form of thread confinement (see 2.3.2) of these objects. If flawlessly adhered to, this eliminates the need for dynamic locking within operations on these objects, thus improving performance. This can also reduce complexity for applications that do not otherwise need to construct threads.
This is the basis for the Swing single-thread rule: With only a few exceptions, all manipulation of Swing objects must be performed by the event handler thread. While not stated in AWT, it is good idea to observe this rule there as well.
Events should not be enabled until their handlers are fully constructed and are thus ready to handle events. This holds as well for other thread-based designs (see 2.2.7), but is a more common source of error here because registering an event handler or listener inside its constructor is not as obvious a way to prematurely enable concurrent execution as is constructing a thread.
Users of the event framework must never dispatch actions that block in ways that can unblock only as a result of handling a future event. This problem is encountered when implementing modal dialogs in most event frameworks, and requires an ad-hoc solution. However, more localized solutions can be obtained merely by setting a disabled state for interactive components that should not be used until a certain re-enabling event is received. This avoids blocking the event queue without allowing undesired actions to be triggered.
Further, to maintain responsiveness of the event framework, actions should not block at all, and should not perform time-consuming operations.
This set of design choices causes event frameworks to have much better performance than would thread-per-event designs, and makes them simpler to program by developers who do not otherwise use threads. However, the usage restrictions have more impact in programs that do construct other threads. For example, because of the single-thread rule, even the smallest manipulations of GUI components (such as changing the text in a label) must be performed by issuing runnable event objects that encapsulate an action to be performed by the event handler thread.
In Swing and AWT applications, the methods javax.swing.SwingUtilities.invokeLater and java.awt.EventQueue.invokeLater can be used to execute display-related commands in the event handler thread. These methods create runnable event objects that are executed when taken from the queue. The online supplement contains links to a SwingWorker utility class that partially automates conformance to these rules for threads that produce results leading to screen updates.
126.96.36.199 Timers
The fact that Runnable tasks in worker thread designs may sit queued without running is a problem to be worked around in some applications. But it sometimes becomes a feature when actions are intended to be delayed.
The use of worker threads can both improve efficiency and simplify usage of delayed and periodic actions — those triggered at certain times, after certain delays, or at regular intervals (for example, every day at noon). A standardized timer facility can both automate messy timing calculations and avoid excess thread construction by reusing worker threads. The main trade-off is that if a worker blocks or takes a long time processing one task, the triggering of others may become delayed longer than they would be if separate Threads are created and scheduled by the underlying JVM.
Time-based daemons can be constructed as variants of the basic worker thread design described in 188.8.131.52. For example, here are the highlights of a version that relies on an unshown priority queue class (that might take a form similar to the scheduling queue illustrated in 4.3.4) and is set up to support only one worker thread:
class TimerDaemon { // Fragments static class TimerTask implements Comparable { // ... final Runnable command; final long execTime; // time to run at public int compareTo(Object x) { long otherExecTime = ((TimerTask)(x)).execTime; return (execTime < otherExecTime) ? -1 : (execTime == otherExecTime)? 0 : 1; } } // a heap or list with methods that preserve // ordering with respect to TimerTask.compareTo static class PriorityQueue { void put(TimerTask t); TimerTask least(); void removeLeast(); boolean isEmpty(); } protected final PriorityQueue pq = new PriorityQueue(); public synchronized void executeAfterDelay(Runnable r,long t){ pq.put(new TimerTask(r, t + System.currentTimeMillis())); notifyAll(); } public synchronized void executeAt(Runnable r, Date time) { pq.put(new TimerTask(r, time.getTime())); notifyAll(); } // wait for and then return next task to run protected synchronized Runnable take() throws InterruptedException { for (;;) { while (pq.isEmpty()) wait(); TimerTask t = pq.least(); long now = System.currentTimeMillis(); long waitTime = now - t.execTime; if (waitTime <= 0) { pq.removeLeast(); return t.command; } else wait(waitTime); } } public TimerDaemon() { activate(); } // only one void activate() { // same as PlainWorkerThread except using above take method } }
The techniques discussed in 3.7 can be used here to improve efficiency of the waiting and notification operations.
This class can be extended to deal with periodic tasks by including additional bookkeeping to requeue them before running them. However, this also requires dealing with the fact that periodically scheduled actions are almost never exactly periodic, in part because timed waits do not necessarily wake up exactly upon the given delays. The main options are either to ignore lags and reschedule by clock time, or to ignore the clock and reschedule the next execution at a fixed delay after starting the current one. Fancier schemes are typically needed for multimedia synchronization — see the Further Readings in 1.3.5.
Timer daemons1 can additionally support methods that cancel delayed or periodic actions. One approach is to have executeAt and other scheduling methods accept or return suitably a reworked TimerTask supporting a cancel method that sets a status flag honored by the worker thread.
4.1.5 Polling and Event-Driven IO
Most worker thread designs rely on blocking channels in which the worker thread waits for incoming commands to run. However, there are a few contexts in which optimistic-style retry loops provide a better solution. Most involve the execution of commands stemming from messages received across IO streams.
It can be a challenge to achieve low latencies and high throughputs in heavily loaded IO-bound systems. The time taken to create a thread that performs an IO-based task adds latency, but most run-time systems are tuned such that, once threads are created, they are very responsive to new inputs arriving on IO streams. On input, they unblock with shorter latencies than you are likely to achieve via other techniques. Especially in the case of socket-based IO, these forces generally favor thread-per-IO-session designs, where a different thread is used (or reused) for each session relying on input from a different connection.
However, as the number of simultaneously active connections climbs, other approaches are (only) sometimes more attractive. Consider for example, a multiplayer game server, or a transaction server, with:
Thousands of simultaneous socket connections that join and leave at a steady rate, for example, as people start and finish playing a game.
Relatively low input rates on any given socket at any given time. However, summing across all connections, the aggregate IO rates may be very high.
Non-trivial computation associated with at least some inputs, for example those that cause global state changes in games.
On large mainframe systems, this kind of problem is sometimes dealt with by creating a special-purpose front-end machine that multiplexes all of the inputs into a single stream that is then dealt with by the main service. The main service is often multithreaded, but its structure is simplified and made more efficient because it does not need to deal with so many apparent clients at a time.
A family of polling and event-driven designs approach such problems without requiring special front ends. While they are not (as of this writing) explicitly supported by the java.io and java.net classes, enough of the ingredients are provided to allow construction of designs that can attain good performance in these kinds of situations. (The designs are analogous to those using socket select and poll operations in other systems and languages.) We'll illustrate with inputs on sockets, but the approach also applies to outputs, to files, and to IO using more exotic devices such as sensors.
22.214.171.124 Event-driven tasks
Many IO-based tasks are initially written in a session-based style (see 2.3.1), continuously pulling commands from sockets and processing them. For example:
class SessionTask implements Runnable { // Generic code sketch protected final Socket socket; protected final InputStream input; SessionTask(Socket s) throws IOException { socket = s; input = socket.getInputStream(); } public void run() { // Normally run in a new thread byte[ ] commandBuffer = new byte[BUFFSIZE]; try { for (;;) { int bytes = input.read(commandBuffer, 0, BUFFSIZE); if (bytes != BUFFSIZE) break; processCommand(commandBuffer, bytes); } } catch (IOException ex) { cleanup(); } finally { try { input.close(); socket.close(); } catch(IOException ignore) {} } } }
To enable many sessions to be handled without using many threads, the tasks first must be refactored into an event-driven style, where an event here signifies IO availability. In this style, a session consists of possibly many executions of its event-triggered task(s), each of which is invoked when input becomes available. Event-driven IO tasks are similar in form to GUI event handlers. A session-based design can be converted into an event-driven form by:
Isolating the basic per-command functionality in a reworked task run method that reads one command and performs the associated action.
Defining the run method so that it can be repeatedly triggered whenever input is available to be read (or an IO exception occurs).
Manually maintaining completion status so that the per-event action is no longer triggered when the session finishes, normally because the input has been exhausted or the connection has been closed.
For example:
class IOEventTask implements Runnable { // Generic code sketch protected final Socket socket; protected final InputStream input; protected volatile boolean done = false; // latches true IOEventTask(Socket s) throws IOException { socket = s; input = socket.getInputStream(); } public void run() { // trigger only when input available if (done) return; byte[ ] commandBuffer = new byte[BUFFSIZE]; try { int bytes = input.read(commandBuffer, 0, BUFFSIZE); if (bytes != BUFFSIZE) done = true; else processCommand(commandBuffer, bytes); } catch (IOException ex) { cleanup(); done = true; } finally { if (!done) return; try { input.close(); socket.close(); } catch(IOException ignore) {} } } // Accessor methods needed by triggering agent: boolean done() { return done; } InputStream input() { return input; } }
22.214.171.124 Triggering
When the events driving each event-driven task are relatively infrequent, a large number of tasks can be processed by a small number of worker threads. The simplest case occurs when the number of worker threads is exactly one. Here, the worker thread repeatedly polls a list of open sockets to see if they have any input available (via InputStream.available) or have encountered other IO-related status changes. If so, the worker executes the associated run method.
This style of worker thread differs from the ones in 184.108.40.206 in that, rather than pulling tasks from a blocking queue and blindly running them, the worker must repeatedly check a list of registered tasks to see if any can be run. It removes each task from the list only when it claims to have completed.
One generic form is:
class PollingWorker implements Runnable { // Incomplete private List tasks = ...; private long sleepTime = ...; void register(IOEventTask t) { tasks.add(t); } void deregister(IOEventTask t) { tasks.remove(t); } public void run() { try { for (;;) { for (Iterator it = tasks.iterator(); it.hasNext();) { IOEventTask t = (IOEventTask)(it.next()); if (t.done()) deregister(t); else { boolean trigger; try { trigger = t.input().available() > 0; } catch (IOException ex) { trigger = true; // trigger if exception on check } if (trigger) t.run(); } } Thread.sleep(sleepTime); // pause between sweeps } } catch (InterruptedException ie) {} } }
Several design concerns arise here:
Polling intrinsically relies on busy-wait loops (see 3.2.6), which are intrinsically wasteful (but still sometimes less so than context-switching). Coping with this requires empirically guided decisions about how to insert sleeps, yields, or alternative actions to strike a balance between conserving CPU time and maintaining acceptable average response latencies.
Performance is very sensitive to the characteristics of the underlying data structure maintaining the list of registered tasks. If new tasks come and go regularly, the list of tasks can change fairly frequently. In this case, schemes such as copy-on-write (see 2.4.4) usually do not work well. But there is every reason to make traversal of the list as cheap as possible. One approach is to maintain a cached list for traversal and to update it (if necessary) only at the end of each sweep.
Event-driven tasks should be triggered only when they have enough data to perform their associated actions. However, in many applications (for example those using free-form string-based commands), the minimal amount of data needed for triggering is not known in advance. In practice (as illustrated here), it usually suffices just to check that at least one byte is available. This exploits the fact that socket-based clients send packets — normally each packet contains an entire command. However, when commands do not arrive as units, the worker thread can stall, thus increasing latencies of other tasks unless buffering schemes are added.
A single worker thread is not likely to be acceptable if some inputs lead to time-consuming computations or blocking IO. One solution is to require that such computations be performed in new threads or by separate worker thread pools. However, it is sometimes more efficient instead to employ multiple polling worker threads; enough so that on average there will always be a thread polling for inputs.
The use of multiple polling worker threads requires additional coordination to make sure that two workers are not both trying to run the same task at the same time, without otherwise impeding each other's sweeps through the list of tasks. One approach is to have task classes set and honor busy status, for example, via testAndSet (see 184.108.40.206).
Given these concerns and the context dependence of the associated design decisions, it is not surprising that most frameworks are custom-built to suit the demands of particular applications. However, the util.concurrent package available from the online supplement includes some utilities that can be used to help build standardized solutions.
4.1.6 Further Readings
Most details about messages, formats, transports, etc., used in practice are specific to particular packages and systems, so the best sources are their accompanying manuals and documentation.
Discussions of message passing in distributed systems can be found in the sources listed in 1.2.5. Any of several packages and frameworks can be used to extend the techniques discussed here to apply in distributed contexts. For example, most of these designs (as well as most in 4.2 and elsewhere in this book) can be adapted for use in JavaSpaces. Conversely, many distributed message passing techniques can be scaled down to apply in concurrent, non-distributed settings.
Design and implementation using JavaSpaces is discussed in:
Freeman, Eric, Susan Hupfer, and Ken Arnold. JavaSpaces™: Principles, Patterns, and Practice, Addison-Wesley, 1999.
For different approaches, see for example the Aleph, JMS, and Ninja packages, accessible via links from the online supplement. Many commercial distributed systems are based on CORBA and related frameworks, which also include some support for oneway message passing. See:
Henning, Michi, and Steve Vinoski. Advanced CORBA Programming with C++, Addison-Wesley, 1999.
Pope, Alan. The CORBA Reference Guide, Addison-Wesley, 1998.
Some systems-level oneway messaging strategies otherwise similar to those presented here are described in:
Langendoen, Koen, Raoul Bhoedjang, and Henri Bal. "Models for Asynchronous Message Handling", IEEE Concurrency, April-June 1997.
An argument that single-queue, single-thread event frameworks are a better basis for application programming than thread-based frameworks may be found in:
Ousterhout, John. "Why Threads Are a Bad Idea (For Most Purposes)", USENIX Technical Conference, 1996.


text:
By: Sheryl Skutelsky
I've personally switched MS medications 3 times over the 14 years since I was diagnosed. It was a little over a year ago that I went for monthly infusions.
I would walk into the infusion center, and no matter how hectic it seemed at times, there was Kristen always smiling. Especially in the beginning, this was a place of fear for me. My veins saw a needle coming, and they would literally slide to the side. Kristen had the patience of a saint, and the most amazing bedside manner.
Unlike so many, I wasn't doing well on the medication. I began to experience severe joint pain, and I finally had to give up and move on to the next medication.
However, I will never forget the difference it made in my life to have a nurse like Kristen. She cared about each and every one of us, and I swear she could do 20 things at once and get them all right.
To this day whenever I visit my neurologist, and he says that I need bloodwork done, I'll patiently wait until Kristen has a free moment – not just because she's the only one that can find my vein on one try, but because her smile can light up anyone's bad MS days.
*Sheryl Skutelsky, diagnosed in 2001, has learned how to live positively with multiple sclerosis. Sheryl's passion has always been graphic design. Her symptoms have become an inconvenience to her work, so she now uses her skills and creativity to reach out to others about MS. Sheryl is a patient advocate speaker for Biogen Idec. She also writes for Healthline.com, and she is an Internet radio host with her own show, Fix MS Now. Check out her Fix MS Now page on Facebook which has more than 10,000 followers. You can help raise MS awareness one "like" at a time by visiting: http://www.facebook.com/fixmsnow.


text:
Terrance Knighton Jersey
The noise during the night sequences tends to vary in how bad it is, moncler some scenes feel very light and almost intentional while others are far too noisy for their own good. The back cover has some animation artwork of Masane in her normal form where the Witchblade is lit up and starting to kick in on its transformation. Safety bars and window guards can play a vital role in guaranteeing the protection of youngsters and pets. Window openings, moncler especially on upper floors pose a falling hazard for youngsters and pets. But with the bars installed, parents and caretakers can have satisfaction knowing they don t have to fear about any incidences happening. The magnetic field of the first electron at lab 1 is undetermined because no measurement has been made, therefore no magnetic field can possibly be present, $B = 0$. (Please correct if wrong) Now, we measure the second electron s spin by sending through a Stern Gerlach device and having that electron hit a screen to record its spin value, $+$ or $ $, at lab 2. The most important thing to know about this memory process is that even when it doesn t work, it still works! For example, if you get stuck trying to make a picture out of someone s name, skip it for now. The next day, when you have a chance, give the matter a few minutes of concentrated thought. If you still can t get a picture, stop and take up the matter a week later. Even if you re still unsuccessful at creating a mental image, Demarco Murray Jersey you ve thought about the prospect s name so much, there s now no way you ll ever forget it! So you ve actually accomplished what you set to do in the first place. Online credit card application is very straightforward. Just follow the directions as prompted. Credit card companies have their respective web sites which are easy to search in the web. Just type the name of the bank, department store/specialty shop, or airlines and add the key words "online credit card application", and the computer screen will display Bacarri Rambo Jersey the search results as well as the URL. NIST and their national partner organisations indicated that a great deal of awareness raising work had been undertaken and informants considered that Choose Life had been effective in raising the profile of suicide Will Montgomery Jersey with the public and among services and in communicating the message that suicide is not only a medical problem. However, there was a shared awareness that further work was required. National organisations considered that closer coordination to link the awareness raising activities of different organisations would create a more effective united front in work with the media, with clear, consistent messages, and the opportunity to pool resources and expertise


text:
Final Fantasy XIV To Finally Charge Money, New Version Next Year
by Craig Getting on October 14, 2011 12:38 PM ESTAfter thirteen months of an extended free trial, Square-Enix's MMO Final Fantasy XIV will begin charging a subscription fee. The subscription-based billing system will go into effect sometime between late November and early December, said Square-Enix president Yoichi Wada.
"In the ten months since the FINAL FANTASY XIV team's restructuring, we have put forth the utmost effort into not only improving the game's existing features, but also creating a concrete plan to outline the game's new direction," Wada said in a statement.
The game's new direction includes the reworking of in-game maps, a new client and new servers, and the eventual release of the PlayStation 3 version in late 2012. A second, shorter free trial period will be offered during that process.
Upon launch, Final Fantasy XIV was criticized for a whole host of problems: interface design, the in-game economy, busted quests, and general instability. This prompted Square Enix to rebuild the Final Fantasy XIV development team and keep the game in a perpetual free trial. Wada even said last month that "the Final Fantasy brand has been greatly damaged" by Final Fantasy XIV's broken launch. How running a subscription MMO in an increasingly free-to-play market will help rebuild the brand remains to be seen.
Current players will be given subscription billing details via email, and those interested can check out various PDFs of the team's overall plan here.
Source: Lodestone
13 Comments
View All Comments
FITCamaro - Friday, October 14, 2011 - link
Ingame maps, a client, and servers?
That's all the information we get? The maps were fine. The client was stable (for me anyway). The servers were also fine. One of the main problems was the lack of an auction house. The ingame npc bazaar idea was retarded and greatly complicated the economy. Instead of a single place to shop with the option to go to player's bazaars, you were forced to. Which meant potentially an hour or more of searching people's bazaars for the item you wanted at a good price. It was a horrible model.
Honestly that was my biggest complaint. And the lack of side quests other than the same missions over and over to level up on until you got to the right level to start the next part of the main quest line. But that was kind of expected. FFXI was the same way when it was released.
If this comes out before The Old Republic in December, I'll probably give it another shot. As a beta tester for ToR I know what to expect there and am overall happy. But I loved FFXI and really hoped FFXIV would succeed. So I'll give it another try. -
whickywhickyjim - Friday, October 14, 2011 - link
Does anyone still play the FF games? 2006 called. It insists this game needs more giant enemy crab. -
evotech - Friday, October 14, 2011 - link
Did you warn them about japan? and the tornadoes? -
foolsgambit11 - Tuesday, October 18, 2011 - link
Thanks, xkcd. -
Lazaron - Friday, October 14, 2011 - link
There's some interesting things coming, but they're a long way off. The maps were a little bland and the UI was a trainwreck, but I can look past those.
It was the tedious and grindy gameplay that really turned me off. I thought it was a pretty fun game until I finished up the tutorial and the game told me I needed to just go grind out these random kill missions until I was high enough level for more main story.
I've done the grindy MMO for years, but I'm just not satisfied by that formula anymore. -
reclinemusic1 - Friday, October 14, 2011 - link
FFXIV V2.0 is NOT coming this year, its coming next year. 2012. Please read the release. -
Craig Getting - Friday, October 14, 2011 - link
Fixed! -
prophet001 - Friday, October 14, 2011 - link
>>> -
Wolfpup - Friday, October 14, 2011 - link
I quite possibly would have bought it to just to mess with it for a year had I know that LOL -
Proxy711 - Saturday, October 15, 2011 - link
More like mess with it maybe a week before you came to the conclusion it wasn't worth your time.


text:
- Accueil
- International Programme
- Publications
- Colloques
- Séminaires
- Blog
- Prix du Jeune Auteur
One Best Way ? Trajectories and Industrial Models of the World's Automobile Producers
Soumis par administrateur le 1 juin 2009 - 19:38
- Chrysler
- Fiat
- Ford
- General Motors
- Honda
- Nissan
- Peugeot
- Renault
- Rover
- Toyota
- Volkswagen
- Allemagne
- Etats-Unis
- Japon
- France
- Italie
- Russie
- Royaume-Uni
- Allemagne
- compromis de gouvernement d'entreprise
- Etats-Unis
- France
- Italie
- Japon
- modèles productifs
- Ouvrages du Gerpisa
- relation salariale
- Royaume-Uni
- Russie
- trajectoire
- Ouvrages du Gerpisa
Type de publication:
Oxford University Press, Oxford, p.476 (1998)URL:
Allemagne, compromis de gouvernement d'entreprise, Etats-Unis, France, Italie, Japon, modèles productifs, Ouvrages du Gerpisa, relation salariale, Royaume-Uni, Russie, trajectoireRésumé:
The three supposedly successive production systems, craft, mass production and lean production, are actually the result of historic amalgams and conceptual ambiguities. The socalled craft system includes craft based companies, but also genuine industrial companies, even if they continued to produce vehicles at fixed work stations. These companies did not disappear from the United States in the inter-war years because of a lack of competitiveness, but due to a lack of liquidity, as revealed in Chapter 2 by Dan Raff. 'Mass production', otherwise known as the 'Taylor-Ford' system, encompasses different models, even if they do share certain principles in common. The Fordist model that can be seen today is different from Henry Ford's initial conception, and should not be confused either historically or conceptually with the Taylorist model or with the Sloanist model, for instance. The Fordist model has not been as universal as is often made out. Not only has it failed in countries where the conditions it required did not exist, but neither has it been automatically adopted in countries, like Japan, where mass production was certainly possible (Fujimoto and Tolliday 1998). The so-called lean production model is a combination of characteristics borrowed from various Japanese companies (Mair 1994). Finally, Toyota has been questioning the core components of its system at the very moment that it was being projected as the paradigm for the 21st century, as Koichi Shimizu reveals in Chapter 3.
The belief in a 'one best way' for each major economic era leads the researcher, and even the practitioner, to interpret and analyze companies in terms of how faithful they are to the model considered to be the best, and to interpret their performance, whether superior, equal or inferior to what it is supposed to be, as a function of secondary, temporary or contextual factors which have intervened to modify the presumed cause and effect relationship. This approach frequently obscures the essential, that is, the existence of different profit strategies which require appropriate and coherent means if they are to be implemented effectively.
Lastly, several company leaders, having internalized the reassuring image of the history of the automobile industry presented above, and newly converted to the excellence of 'lean production', forget to properly verify whether their own market, work organization and institutional contexts correspond to the conditions in which the apparently superior model is in fact valid and viable. It is scarcely surprising that they then experience failures, which are too quickly and conveniently explained away in terms of incomprehension of the system, errors of implementation, and resistance to change on the part of certain groups of employees.
For these reasons, the authors of the chapters in this book, together with the entire group of researchers who have participated in GERPISA's international programme 'The Emergence of New Industrial Models', have accepted a requirement to start from empirical research, in this case focused on the trajectories of the automobile producers since the 1970s, prior to drawing conclusions about convergence or plurality of models. Two pitfalls had to be avoided: fastidious description, which too often leads to the conclusion that every case is unique, and superficial comparison that is satisfied to classify companies according to perceived similarities and differences. In contrast, the analytical framework adopted here is based on studying the changes that companies have made to the particular profit strategies and the socio-production systems that characterized them in the 1960s, in the context of the shared or unique problems that they have encountered since the 1970s and which help interpret what their evolution actually means. The authors of this book have then examined the attempts of the companies to make their changes coherent and, where this has been achieved, to characterise the models that have thus been constituted.
The trajectories of fifteen companies have been studied. These encompass the major foreign subsidiaries, such as Opel Vaux hall Saab, for GM and Ford of Europe for Ford, as well as the brands absorbed or taken over since the 1970s, such as Seat and Skoda for Volkswagen, Lancia and Alfa-Romeo for Fiat, Citroën and Chrysler-Europe for PSA, Mazda for Ford, etc. Not all the independent companies that deserved to be studied in the book could be included, notably Mercedes and BMW, due to an absence of academic experts. The companies have been grouped by the three regional poles of the global automobile industry, East Asia, North America, and Europe, given the relative similarity of markets and work contexts facing companies within each pole. This permits the differences of trajectory and models in relatively similar contexts to emerge clearly. However, this principle is not adhered to in two cases: Hyundai, which is grouped with the Japanese companies, and Lada, where production conditions at the time of the Soviet Union were quite unrelated to those in Western Europe. Other parts of the world are not entirely ignored. The subsidiaries of the major producers present there are mentioned within their trajectories, although they are not analyzed directly. Another book resulting from the GERPISA programme studies them from the perspective of the transfer and hybridization of industrial models (Boyer, Charron, Jürgens and Tolliday 1998).
Although to begin with the authors of this book had divergent views, as did many participants in the GERPISA programme (as can be read in the Preface), by the end of the process they agreed that convergence towards a single successful industrial model is no more likely today than in the past.
Introduction, Michel Freyssenet
1. Intersecting trajectories and model changes, Michel Freyssenet
2. Models, Trajectories and the Evolution of Production Systems: Lessons from the American Automobile Industry in the Years Between the Wars, Daniel M. G. Raff
Part 1. Only One Model In Japan?
3. A New Toyotaism? Koichi Shimizu
4. Nissan: Restructuring to Regain Competitiveness, Masanori Hanada
5. The Globalization of Honda's Product-Led Flexible Mass Production System, Andrew Mair
6. The Unique Trajectory of Mitsubishi Motors, Koichi Shimizu and Koici Shimokawa
7. Hyundaï Tries Two Industrial Models to Penetrate Global Motors, Myeong-Kee Chung
Part 2. Three Distinct Trajectories at North America's Big Three
8. The General Motors Trajectory: Strategic Shift or Tactical Drift? Michael S. Flynn
9. Globalization at the Hearth of Organizational Change: Crisis and Recovery at the Ford Motor Company, Gérard Bordenave
10. Reinventing Chrysler, Bruce M. Belzowski
Part 3. Europa's Dilemna; Transfer, Adapt or Innovate?
11. The Development of Volkswagen's Industrial Model, 1965-95, Ulrich Jürgens
12. Making Manufacturing Lean in the Italian Automobile Industry: the Trajectory of Fiat, Giuseppe Volpato
13. Peugeot Meets Ford, Sloan and Toyota, Jean-Louis Loubet
14. Renault: From Diversified Mass Production to innovative Flexible Production, Michel Freyssenet
15. From British Leyland Motor Corporation to Rover Group: the Search for a Viable British Model, Andrew Mair
16. A Second Comeback or a Final Farewell? The Volvo Trajectory, 1973-94, Christian Berggren
17. Lada: Viability of Fordism?, Jean Jacques Chanaron
Conclusion: The Choice to be Made in the Coming Decade, Michel Freyssenet, Andrew Mair, Koichi Shimizu, Giuseppe Volpato
Statistical appendix by automobile producer
Connexion utilisateur
Journée du Gerpisa
Samedi 26 Octobre 2024, 10:00 - 17:00 CEST


text:
Newburgh firm helping victims recover for their losses
The personal injury attorneys at Law Offices of Ernest L. Harris, LLP have more than 25 years of experience successfully helping injured clients recover just compensation for losses resulting from auto accidents, medical malpractice, unsafe products, dangerous drugs, slips and falls, and unsafe work conditions. We also represent people with workers compensation and Social Security disability claims.
Seeking just compensation for injuries
Personal injury claims are brought by victims who suffer physical or psychological injury directly due to another person's negligence. At Law Offices of Ernest L. Harris, LLP, our attorneys employ a practical, professional approach to ensure that our clients obtain full and fair recovery for their injuries, including damages for their past and future medical bills, lost income, emotional distress, and pain and suffering. We use our extensive civil litigation experience, our knowledge about insurance company tactics and our skills at settlement negotiation to obtain the best possible recovery for our clients.
Personalized legal guidance
The client's interests are our priority. We provide personalized legal guidance at every step of your case, updating you on progress and fully informing you about the legal strategy and recovery options available.
Our attorneys consult with knowledgeable and respected experts to help with case preparation. With the assistance of physicians, trauma doctors, pharmacists, chiropractors, forensics engineers, mechanics and accident reconstruction analysts, we are skilled at negotiating the best possible settlements. At trial, these experts are available to deliver clear, professional testimony.
Protecting your claim
New York law sets limits on the amount of time you have to file a personal injury claim. Consult an experienced personal injury attorney as soon as possible so your claim is filed within crucial statutory deadlines. By investigating your claim immediately, we help ensure that valuable evidence remains available and witnesses' memories remain fresh.
Contact the knowledgeable New York personal injury law firm.
The Law Offices of Ernest L. Harris, LLP is conveniently located in Newburgh. In some cases, our attorneys can arrange to visit your home or hospital to ensure timely investigation and filing of your claim. If you or a loved one has been injured, call 1-800-SSD-COMP or contact Law Offices of Ernest L. Harris, LLP online to schedule an initial consultation.


text:
Brantley Gilbert and Carly Pearce to Headline Grand Ole Prix at Big Machine Music City Grand Prix
Brantley Gilbert and Carly Pearce are off to the races. They have been revealed as the headliners for the Grand Ole Prix show at the Big Machine Music City Grand Prix on Sunday, Aug. 7.
The show is a special version of the famous Grand Ole Opry, and it will take place outdoors in Downtown Nashville. Big Machine Label Group's Midland and Callista Clark will perform alongside Gilbert and Pearce. Fans who purchase tickets for the race weekend will have access to the 90-minute show. The show will take place at 5:45PM CT on the ZYN Main Stage.
The Grand Ole Prix show serves as the bookend of the Big Machine Music City Grand Prix weekend. Running Friday, Aug. 5, through Sunday, Aug. 7., the event will see races from the NTT IndyCar Series. The races begin at 10:15AM on Friday, and the last race will occur at 5:05PM on Sunday. Specific races include the Trans Am Series, GT America, Indy Lights Series, Stadium Super Trucks and Vintage Indy.
Downtown Nashville itself will serve as the course for the races. Drivers will begin near Nissan Stadium, after which they will race over the Korean War Veterans Memorial Bridge and into downtown.
The Big Machine Music City Grand Prix will feature other entertainment for the weekend, including the Freedom Friday Tribute Concert with a yet-to-be-announced artist on Friday and the headline concert with Tim McGraw on Saturday. The event will also feature local food trucks and a food court.
Tickets for the Big Machine Music City Grand Prix are on sale now, with three-day tickets and premium packages available. Three-day, general admission tickets begin at $129 and fans can reserve their spot on the grandstand for $209 and $219.


text:
1. Asoka.-King of Magadha. He was the son of Bindusāra. Bindusāra had sixteen wives who bore him 101 sons.
The chief Pāli sources of information regarding Asoka are Dīpavamsa (chaps. i., v., vi., vii., xi., etc.), Mahāvamsa (v., xi., xx., etc.), Samantapāsādikā (pp. 35 ff. ). Other sources are the Divyāvadāna passim, and the Avadānasataka ii.200ff. For an exhaustive discussion of the sources and their contents see Prszlyski, La Legende de l'Empereur Asoka.
The Pāli Chronicles (Dīpavamsa and Mahāvamsa) mention only three of the sons, viz. Sumana (Susīma according to the northern legends) the eldest, Asoka, and Tissa (uterine brother of Asoka) the youngest. The Mahāvamsa Tīka (p.125; Mbv.98. In the northern tradition, e.g., Asokāvadānamālā, she is called Subhadrāngī, daughter of a brahmin of Campā) gives the name of his mother as Dhammā and calls her Aggamahesī (Bindusāra's chief queen); she belonged to the Moriyavamsa. The preceptor of Dhammā's family was an ājīvaka called Janasāna (which probably explains Asoka's earlier patronage of the ājīvakas).
In his youth Asoka was appointed Governor of Avanti with his capital at Ujjeni. The Divy. says he was in Takkasilā with headquarters in Uttarāpatha, where he superseded Susīma and quelled a rebellion. When Bindusāra lay on his death-bed, Asoka left Ujjeni and came to Pātalīputta where he made himself master of the city and possessor of the throne. He is stated in the Mahāvamsa (v.20; Mbv.98) to have killed all his brothers except Tissa that he might accomplish his purpose, and to have been called Candāsoka on account of this outrage (Mhv.v.189). It is impossible to say how much truth there is in this account of the accession. Asoka's Rock Edicts seem to indicate that he had numerous brothers, sisters and relations alive at the time they were written in Pātaliputta and other towns (see Mookherji, Asoka, pp. 3-6). His brother Tissa he appointed as his uparāja (advisor) (Mhv.v.33), but Tissa became a religious devotee attaining arahantship. The Theragāthā Commentary refers to another younger brother of Asoka, Vitasoka, who also became an arahant. (i.295f. The northern works give quite a different account of his brothers, see Mookherji, p.6).
Asoka had several wives. His first wife was the daughter of a merchant of Vedisagiri, whom he met when stopping at the merchant's house on his way to Ujjeni (Mhv.xiii.8ff). Her name was Devī, also called Vedisa-Mahādevī, and she was a Sākiyan, descended from a Sākiyan family who migrated to Vedisa to escape from Vidūdabha (Mbv., pp.98, 116). Of Devī were born a son Mahinda, and a daughter Sanghamittā, who became the wife of Aggibrahmā and mother of Sumana. Devī evidently did not follow Asoka to Pātaliputta, for his aggamahesī (chief-queen) there was Asandhamittā (Mhv.v.85). Asandhamittā died in the thirtieth year of Asoka's reign, and four years later he raised Tissarakkhā to the rank of queen. Mhv.xx.1-3. The Allahabad Pillar Inscription mentions another queen, Kāruvākī, mother of Tivara. The Divy. (chap. xxvii.) gives another, Padmāvatī, Kunāla's mother. Besides the children mentioned above, names of others are given: Jalauka, Cārumatī (Mookherji. p.9).
According to Mahāvamsa (v.21, 22), Asoka's accession was 218 years after the Buddha's death and his coronation was four years later. The chronicles (v.22ff) contain various stories of his miraculous powers. His command spread a yojana into the air and a yojana under the earth. The devas supplied him daily with water from the Anotatta Lake and with other luxuries from elsewhere. Yakkhas, Nāgas and even mice and karavīka birds ministered to his comfort, and thoughtful animals came and died outside his kitchen in order to provide him with food.
At first Asoka maintained the alms instituted by his father, but soon, being disappointed in the recipients, he began looking out for holy men. It was then that he saw from his window, his nephew, the young novice Nigrodha. Owing to their friendship in a past birth (Asoka, Devanampiyatissa and Nigrodha had been brothers, traders in honey, and they gave honey to a Pacceka Buddha. Asandhamittā had been the maiden who showed the honey-shop to the Pacceka Buddha. The story is given in Mhv.v.49ff], Asoka was at once drawn to him and invited him into the palace. Nigrodha preached to him the Appamādavagga and the king was greatly pleased. He ceased his benefactions to other religious orders and transferred his patronage to Nigrodha and members of the Buddhist Order. His wealth, which, according to the Samantapāsādikā (i.52), amounted to 500,000 pieces daily, he now spent in doing acts of piety - giving 100,000 to Nigrodha to be used in any manner he wished, a like sum for the offering of perfumes and flowers at the Buddha's shrines, 100,000 for the preaching of the Dhamma, 100,000 for the provision of comforts for members of the Order, and the remainder for medicines for the sick. To Nigrodha, in addition to other gifts, he sent sets of robes three times each day, placing them on the back of an elephant, adorned by festoons of flowers. Nigrodha gave these robes to other monks (MA.ii.931).
Having learnt from Moggaliputta-Tissa that there were 84,000 sections of the Dhamma, he built in various towns an equal number of vihāras, and in Pātaliputta he erected the Asokārāma. With the aid of the Nāga king Mahākāla, he created a life-size figure of the Buddha, to which he made great offerings.
His two children, Mahinda and Sanghamittā, aged respectively twenty and eighteen, he ordained under Moggaliputta-Tissa and Dhammapālā, in the sixth year of his reign (MA.v.197, 209). This raised him from a paccadāyaka to a sāsanadāyādin.
In order to purge the Order of undesirable monks and heretical doctrines, Moggaliputta-Tissa held the Third Council under the king's patronage. It is said that the pious monks refused to hold the uposatha with those they considered unworthy. The king, desirous of bringing about unity in the Sangha, sent a minister to restore amity, but the minister, misunderstanding his orders, beheaded many holy monks, being at last stopped by the king's brother Tissa, who was then a monk (MA.vs.240ff).
At the conclusion of the Council, held in the seventeenth year of his reign (Ibid., 280; in the northern texts Moggaliputta-Tissa's name is given as Upagupta. It was for this Council that the Kathāvatthu was written), Asoka sent forth Theras to propagate the Buddha's religion:
Majjhantika to Kasmīra and Gandhāra,
Mahādeva to Mahisamandala,
Rakkhita to Vanavāsa,
Yona Dhammarakkhita to Aparantaka,
Mahārakkhita to Yona,
Majjhima to the Himālaya country and
Sona and Uttara to Suvannabhūmi;
Mahinda with Itthiya, Uttiya, Sambala and Bhaddasāla he sent to Lankā
(Ibid., xii.1-8. For particulars of these missions and identification of the places mentioned, see under the different names; this list appears also in the Samantapāsādikā, where further interesting details are given. For a discussion on them see Mookherji, pp.33ff). In the eighteenth year of his reign he sent to Lankā, at Devanampiyatissa's request, Sanghamittā, with a branch of the great Bodhi Tree at Buddhagayā (Mhv.xx.1). A little earlier he had sent by his grandson Sumana, some relics of the Buddha and the Buddha's alms-bowl to be deposited in the thūpas of Lankā (Mhv.xvii.10f).
Asoka reigned for thirty-seven years (Mhv.xx.6). In his later life he came to be called Dhammāsoka on account of his pious deeds (Mhv.v.189). The Dīpavamsa gives his name in several places as Piyadassī. E.g., vi.1, 2, 25. The title Devānampiya used by Asoka in his inscriptions was also used by Tissa, Asoka's contemporary in Ceylon, and by Asoka's grandson Dasaratha (Nāgarjunī Hill Cave Inscription). It was used also by other kings in Ceylon: Vankanāsika Tissa, Gajabāhukagāminī and Mahallaka-Nāga (Ep. Zeyl. i.60.f).
The Chronicles state that Asoka and Devanampiya Tissa of Ceylon had been friends - though they had never seen each other - even before Mahinda's mission to Ceylon. Tissa had sent him, as a friendly gesture, various gifts, and Asoka had returned the courtesy. He sent an embassy of his chosen ministers, bearing gifts marvellous in splendour, that Tissa might go through a second coronation ceremony, and the messengers were directed to give this special message to the king: "I have taken refuge in the Buddha, Dhamma and Sangha and declared myself a follower of the religion of the Sākyaputta. Seek then, even thou, oh best of men, converting thy mind with believing heart, refuge in these best of gems." (Mhv.xi.18-36)
The Milindapanha (p.121) mentions an encounter of Asoka with a courtesan of Pātalīputta, Bindumatī, who, in order to show the king the power of an Act of Truth, made the waters of the Ganges to flow back.
According to the Petavatthu Atthakathā (244ff) there was a king of Surattha, called Pingala, who used to visit Asoka in order to give him counsel. Perhaps he was an old friend or tutor of the king.
Asoka is called a dīpacakkavatti as opposed to padesarājās like Bimbisāra and Pasenadi (Sp.ii.309).
Asoka had three palaces for the three seasons: Mahāsappika, Moragīva and Mangala (Ras.i.93).
2. Asoka.-See Kālāsoka.
3. Asoka.-See Vītāsoka.
4. Asoka.-A brahmin in the time of Kassapa Buddha. He provided eight meals daily for the monks and entrusted the distribution of them to his serving-woman Bīranī. Mhv.xxvii.11.
5. Asoka.-Attendant to Vipassī Buddha (J.i.41; Bu.xx.28). He was once ill and was cured by a doctor who, in this age, was Tikicchaka (Tekicchakānī) Thera. Ap.i.190; ThagA.i.442.
6. Asoka.-The chief disciple of the future Buddha Metteyya (Anāgatavamsa. v.97). According to the Mahāvamsa (xxxii.81) he should be identified with Dutthagāmanī.
7. Asoka.-A monk of Ñātikā. Once when the Buddha was staying at Ñātikā in the Giñjakāvasatha, Ananda mentions to the Buddha that Asoka Thera had died, and asks where he had gone. The Buddha tells him that Asoka was an arahant and had realised Nibbana. S.i.358.
8. Asoka.-See Anoma (7).
9. Asoka.-A mountain near Himavā. There, in the time of Sumedha Buddha, Vissakamma built a hermitage. Ap.ii.342.


text:
Billy Bob Thornton
Though he spent almost a decade struggling to make a name for himself, actor Billy Bob Thornton took matters into his own hands when he wrote, directed and starred in the career-making independent drama, "Sling Blade" (1996), which earned the then-unknown performer an Oscar for Best Screenplay and another nomination for Best Actor. Ever since his sudden rise to stardom, Thornton became a prominent leading man and supporting player whose short-lived but high-profile marriage to offbeat starlet Angelina Jolie overshadowed his exemplary work in films like "Monster's Ball" and "The Man Who Wasn't There" (2001). After their divorce, Thornton receded a bit from the public eye, though he continued his streak of fine performances in "Bad Santa" (2003) and "Friday Night Lights" (2004), two wildly different films that displayed his prowess for disappearing into what ever character he played. Occasionally, Thornton incorporated his own personal issues - namely his battles with eating and obsessive-compulsive disorders, like a fear of Louis XIV furniture - into his characters, as he did in "Bandits" (2001). Despite his seemingly bizarre personal life, Thornton nonetheless maintained a steady stream of quality work that always kept him near the top of the game.


text:
The operations center enables the sharing of cloud configuration across the controllers in the operations center cluster.
The sharing model used for shared cloud configuration is similar to the shared configuration propagation.
Unlike shared clouds or shared agents, shared cloud configuration replicates the configuration of the cloud provider to the specified controllers such that each controller has separate control of the cloud rather than leasing agents from the operations center server.
Shared cloud configuration can also be complished via Configuration as Code (CasC). |
Supported cloud providers
Amazon Elastic Compute Cloud (EC2) from Amazon EC2 Plugin is supported for shared cloud configuration.
The shared cloud configuration is licensed individually for each cloud type. |
The plugin defining the configuration must be installed on the controllers to which the configuration will be propogated.
The plugin versions on the controller(s) and the operations center server must be compatible in terms of configuration data model.
Violations of the requirements above may have a serious impact on cloud provisioners on controllers. |
Shared configuration setup
Shared configurations should be created as Jenkins items like controllers, folders and templates using the New Item
action on the left hand menu in operations center. Items can be created at the root of the instance or within a folder.
If you create in the root of operations center, the cloud will be available to all controllers
If you create a shared cloud configuration item in a folder, the cloud will be available only to controllers within the folder or within the folder's sub-folders.
Step 1. Create a new configuration item
Click on the "New Item" action in Jenkins root or a folder. In both cases you will be presented with the standard new item screen.
Provide a configuration name.
Select the
Cloud Configuration
type that you wish to create. -
Click on
button. A new configuration window will appear.
Step 2. Enter the required configuration for the selected cloud
Options are similar to the standard Jenkins cloud configuration options.
If a cloud provider requires configuration of native tools or libraries, then this location must be the same on all controllers that receive this configuration in order to operate correctly. |
Step 3. Apply changes
When the shared cloud configuration is complete, save or apply the configuration.
The cloud configuration will be pushed to all online controllers that have not opted out of receiving the shared configuration. If a controller is offline, the new configuration will be applied when this controller connects to operations center.
Supported configurations
Below you can find configuration examples for the supported clouds.
As mentioned earlier, prior to configuring a shared-cloud ensure that the plugin defining the launcher is installed on all the controllers within scope for using the shared cloud. |
Amazon Elastic Compute Cloud (EC2)
This Shared cloud configuration allows you to share settings for Amazon EC2 cloud, which is the part of Amazon Web Services platform (AWS).
Please refer to the Amazon EC2 plugin Wiki page to find setup guidelines and information about supported configurations. This section describes the operations center specifics only.
The following apply to both CloudBees CI on modern cloud platforms and CloudBees CI on traditional platforms:
Instance caps are being managed individually for each controller, there is no global limitation for the entire operations center cluster.
If you use
Access Key ID
andSecret Access Key
to define EC2 credentials, these credentials will be shared across all CloudBees CI instances. EC2 must allow multiple logins from different places if you have multiple controllers.
The following apply to CloudBees CI on traditional platforms only:
If all target CloudBees CI instances are running on EC2 instances, you can use
EC2 instance profile
to obtain credentials from the instance's metadata. -
Currently there is no opportunity to set up different
for CloudBees CI instances in AWS EC2 Shared Cloud Configuration. In such cases, use individual setups of EC2 Cloud on each controller.
Testing the configuration
If you click on the
Test Connection
button in the configuration, the test will be launched on operations center. Make sure that the AWS EC2 cloud is available to operations center. -
If the instance is configured to obtain credentials from
EC2 instance profile
, operations center must be running on a properly configured Amazon Machine Image -
You can also test the connection from one of Jenkins controllers when the configuration gets synchronized. It's highly recommended if your AWS EC2 Shared Cloud Configuration uses
EC2 instance profile
to obtain credentials


text:
Some fetishes I get, and some I don't. I don't get this one. As reported in The Courier Mail:
After a night out at a pub in Boggabri, in northern NSW [New South Wales, Australia], a group of people went to a private home on March 27.
So far, so good.
"Police will allege that a man went to the home's bathroom and set up his mobile phone to record people going to the toilet," police said in a statement. "
Uh oh.
About 1am a 29-year-old woman went to the bathroom to use the toilet and discovered the phone. "The woman viewed the recording, seized the phone and left the gathering."
Dude probably forgot to turn the ringer off.
Police were alerted to the matter and yesterday arrested a 36-year-old man at the property. He has been charged with filming a person in private without consent and is due to face Narrabri Local Court on May 25.
Not cool.


text:
The Local and Regional Authorities (LRA) process will highlight Local and Regional Authorities' major role in achieving the Millennium Development Goals.The 6th Forum will build on the results of the political processes organised previously. Thereby, the Istanbul Water Consensus (IWC), main output of the LRA political process of the 5th World Water Forum (Istanbul, 2009), is the cornerstone of the LRA process of the 6th World Water Forum.
Contact : email@example.com
On the occasion of the 6th World Water Forum, held in Marseille from 12 to 17 March 2012, 350 local and regional elected officials from across the 5 continents have met to increase international the mobilization of local and regional authorities on the issues of water and sanitation and to reinforce the commitments agreed upon in the Istanbul Water Consensus. In the framework of the Forum's political process, the World Water Council organized, jointly with UCLG, the 3rd International Conference of Local and Regional Authorities for Water. With 12 thematic sessions, this International Conference presented the advances realized under the Istanbul Water Consensus since its adoption during the 5th World Water Forum in 2009, and allowed participants to exchange on key issues such as water and urbanization, cooperation and solidarity, as well as regional governance.
Political Message from Local and Regional Authorities
Photos and Videos of the Conference of Local and Regional Authorities
Photos from the Opening ceremony are available here:
Photos from the Ceremony of signature of the Istanbul Water Consensus are available here:
Videos are available here: http://www.worldwaterforum6.org/?id=306
It's a global compact signed on a voluntary basis by Local and Regional Authorities willing to adapt their water infrastructure and services to the emerging challenges they are increasingly facing such as climate change, rapid urban growth, depletion and pollution of water resources or ageing infrastructure.
Through the signature of the document, LRA commit to prepare action plans, to develop targets and related indicators to monitor progress toward these targets. The implementation phase is being supported by a number of Champion Cities acting as drivers and guides for implementation on particular challenges. Cities and Regions also commit to reporting back on the progress at the 6th World Water Forum in Marseille.
As of March 2012, more than 1000 Mayors from 58 countries have signed it.
The text of the Istanbul Water Consensus is available in 9 languages:
1. Get approval from the appropriate local authority
2. Fill in the Form:
- online
- download it in French, English, Spanish or Portuguese
3. Return it to the World Water Council,
- by e-mail: email@example.com
- or by fax: +33 4 91 99 41 01
4. Define your targets and commitments (cf.Guidelines in Annex of the Istanbul Water Consensus) and send your electronic file (Excel, Word, Pdf or ppt) to firstname.lastname@example.com
Ultimately, the expected outcome of this process is a stronger recognition of the role of Local and Regional authorities in the global political debate on water.


text:
When you first launch a business, you can be so focused on daily operations that you don't take the time to take a step back and realize it actually might be time to expand. It's exciting when you recognize that your business – something that had been an idea in your head, a dream – has caught on with customers. As thrilling as this success can be, growing your business can be just as scary as starting it. You want to make sure that you're doing things the right way, at the right time, to avoid mistakes that could jeopardize your company. Here are five indicators that it could be time to grow your business:
1. You can't keep up with demand.
The decision to expand should never be prompted by a desire to stick to an arbitrary growth plan when you don't have any real justification for doing so. Before you even consider expanding, ask yourself if there's a need. Do you have more orders than your staff and facilities can handle? Can you accommodate the number of customers that you're attracting? If your numbers warrant growth, that's the first step.
2. You have a solid team in place.
A strong group of employees is essential when you're considering expanding. If you're planning to open new locations, you're going to be spending a good deal of time getting things up and running in those areas, so you need to have people you trust to hold down the fort. If you don't have confidence in your team, make some changes and key hires before moving forward. Also, ask yourself if you need to hire more employees. Before you expand, you'll want a competent, well-trained team ready to go.
3. You have enough cash.
Expansion takes money. So, even if you have a stream of orders coming in, you're not in a position to grow unless you're actually getting paid. Only when you have strong, positive cash flow should you consider taking the next step.
4. You're running out of space.
Whether you're working in a restaurant, a manufacturing facility or a commercial kitchen, you obviously need enough room to operate comfortably. And if the number of customers visiting your business has spiked or you've increased staff but are still in the same space, everyone is going to get frustrated. Don't be hasty about leasing a larger space or opening a new location. First, make sure that your growth is consistent and not just a seasonal spike. Also, don't get ahead of yourself. Expand gradually to avoid investing in a space that's too large or expensive for your business to sustain.
5. There's a demand for more products and services.
If you've created a product that has taken off, think about variations you could make. For example, if it's a food product, think about new flavor and size options. If it's an item of clothing, consider more colors and fabric. Also, take your customers' input seriously. If they're consistently asking for something you don't offer, or if they have an interesting idea for a new flavor or product, it might be something worth pursuing.
Related Articles
How to Open a Salon
7 Time Management Skills Practiced by Successful People
Five Ways Square Analytics Can Help You Run Your Business


text:
We have the answer for Like a soft, juicy mango crossword clue in case you've been struggling to solve this one! Crossword puzzles can be an excellent way to stimulate your brain, pass the time, and challenge yourself all at once. Of course, sometimes there's a crossword clue that totally stumps us, whether it's because we are unfamiliar with the subject matter entirely or we just are drawing a blank.
Now, let's get into the answer for Like a soft, juicy mango crossword clue most recently seen in the Universal Crossword.
Like a soft, juicy mango Crossword Clue Answer is…
Answer: RIPE
This clue last appeared in the Universal Crossword on January 1, 2024. You can also find answers to past Universal Crosswords.
Related Universal Crossword Answers
You can play the Universal Crossword online.
Clue & Answer Definitions
- JUICY (adjective)
- lucrative
- suggestive of sexual impropriety
- RIPE (adjective)
- far along in time
- fully developed or matured and ready to be eaten or used
Historical Usage in Crossword Puzzles
About the Universal Crossword
The Universal Crossword is a daily crossword puzzle that is syndicated to newspapers and online publications around the world. The puzzle is created by a team of experienced crossword constructors, who are known for their skill and creativity in the field of crossword puzzles.
The Universal Crossword was first introduced in 1999, and has since become a popular source of entertainment and mental stimulation for crossword enthusiasts of all ages. The puzzle is known for its clever clues and challenging difficulty level, and is updated daily with new and interesting themes.
One of the unique features of the Universal Crossword is its use of a standardized grid size, which makes it easy for solvers to switch between different crossword puzzles without having to adjust to a new grid layout. The puzzle is also known for its inclusion of a wide range of topics, from pop culture and current events to science and history.
That should be all the information you need to solve for the Like a soft, juicy mango crossword clue answer to help you fill in more of the grid you're working on! Be sure to check more Crossword Clues, Crossword Answers, and our other Word Game coverage.


text:
"Our work as artists is courageous and scary. There is no brief that comes along with it, no problem solving that's given as a task....An artist's work is almost entirely inquiry based and self-regulated. It is a fragile process of teaching oneself to work alone, and focusing on how to hone your quirky creative obsessions so that they eventually become so oddly specific that they can only be our own." - Teresita Fernandez
From an old series several years ago.
A primitive Songye figure or Nkisi (from the Democratic Republic of the Congo) started my thought process about doing a series.
I thought he was rather ugly at first though some would disagree because he has a raw, primitive energy and charm and in any case he was not created to be a work of art but an Nkisi. An Nkisi is a power figure that is believed to have protective powers for the owner and his family.
Wrapped around the large figure are a number of smaller figures which could be handed out to those who needed protection from evil or misfortune. When the need for protection had disappeared the small figures would then be returned to the bigger figure.
I fell in love with this Songye Ceremonial vessel. It is a gourd with an inner basket (containing potatoes, I think) and several miniature power figures attached to the outside.
Nestled amidst the wood shavings on my worktable .... a favourite place to photograph my carvings.
It was important to me that my Healing Goddesses exuded a feel good energy and I can only hope that I've achieved that. It was certainly therapeutic to carve them.