The following was a question a anonymous visitor asked: Jim can fill a pool carrying buckets of water in 30 minutes. Sue can do the same job in 45 minutes. Tony can do the same job in 1 ½ hours. How quickly can all three fill the pool together?
Work problem 5 solution here
I know I know, I'm very bad ! But I couldn't help it, I've joined the Template HOTP Personal shopper. I thought why not since the pound is getting stronger and it's delivered every other month. This month the template allows you to make this lovely basket ! I've used the papers that came with the kit and the brads too. We also received as a thank you gift another mini template to make envelopes.
Screen size:
When using non-transactional queues processing a message is trivially easy—just handle the message and write to your data store. If the process dies and we lose a message, that’s okay. But when using a transactional queue things can become more difficult because we want our infrastructure to ensure consistency between our message queues and application database. I have already outlined the trouble of using two-phase commits in a previous post.
What if we were able to handle the inconsistency between our message queue and application data store at an application rather than infrastructure level? What if we embraced receiving duplicate messages? What if our application had the ability to make message processing idempotent, despite the message not being idempotent? What if we were able to pi! ck and choose the messages that that became idempotent on a per-message type basis?
A Typical Example
Let’s go through a typical message processing example to see how this might work.
When everything is working properly we:
But what about failure conditions? This is exactly the type of thing that transactions are designed to handle. How can we maintain application integrity without 2PC? L! et’s consider a few failure conditions.
When the database transaction fails:
When the process comes back online, it’s going to pick up right where it left off and the application and message queue will be in a consistent state.
Now let’s examine a failure condition where the database commits but resulting messages failed to publish because of a power or hardware failure.
Herein lies the problem. When the process comes back up, it’s going to reprocess the message…but it’s already been processed. How do we handle that?
The Solution
What if we were to keep a log of all received messages (at least their identifiers) along with all bus activity (Publish, Send, Return, Reply) associated with the processing of that message? What if we stored that list as part of our application state during the commit operation? Doing so would allow us to check if a message was already processed. If it was already processed, we could get the associated messages that resulted from processing and redispatch them. It may be worth noting that event sourcin! g already stores all of the changes that resulted from process! ing a me ssage. In that scenario you’re already saving the data, now it’s just a small initial check before processing.
What I have outlined above is actually a well-understood pattern and some message queue providers even provide database hooks to facilitate message de-duplication. Pat Helland who worked at Amazon and Microsoft wrote a really good paper on this exact same topic a few years back. One critical difference between what Pat proposes vs. what the message queue providers do is that Pat always works on local copies of data. In other words, the boundary of each transaction is against a single machine or tightly bound cluster of machines. This rings true to me because it is harmonious with SOA principles.
I recently created a proof of concept around these very same! principles and I call it “IdempotentConsumer”. It’s an NServiceBus message handler along with associated application services that facilitate de-duplication of a message before handing it off. In my proof of concept I am relying on two concepts—that each logical business message can be uniquely identified by a business identifier specific to the message and that each message is addressed to a single business entity—like an aggregate root. Plug-ins could be written to work with alternative storage engines.
UPDATE: IdempotentConsumer has been updated to utilize more optimistic styles of concurrency. Rather than checking each message that arrives before handing it off to the application, we instead assume that messages are not duplicate and handle any optimistic concurrency exceptions raised by our data store.
NoSQL
While the above wo! rks great when you have a resource that supports transactional! integri ty in the form of TransactionScope, it becomes more difficult when working with NoSQL storage engines, such as CouchDB, Cassandra, Riak, etc.
In a relational DB we can perform multiple writes to various tables and have all writes be transactional. In NoSQL the boundary of a transaction is a single write. Multiple writes means multiple transactions. Granted, CouchDB does support batching, but you lose some consistency checks when doing a batch write to multiple documents simultaneously, such as the ability to raise an optimistic concurrency exception if you’re not writing using the latest version of a particular document.
So how do we write the list of published messages resulting from the message currently being processed and maintain transactional integrity with the changes in application state? Easy.
Write the list of messages to be published as a result of processing the ! incoming message. Once that transaction is complete, write the associated document containing the changes in application state--but include the ID of the message being processed *inside* the document. When we query to obtain the list of messages we do a server-side or client-side MapReduce of sorts to effectively “join” the list of published messages with the associated parent message ID found in the application state document/row. If the application state contains the ID found in the list of messages, redispatch the stored messages and we’re done. If it doesn’t, delete the list of published message—they were never published because a failure occurred prior to writing the application state record.
Because we are doing this on a per-message type, we can customize the way we query each business object—we can have a standard way of querying most and then customize the way we qu! ery specific ones depending upon how they store the parent mes! sage ID. We can vary the way we query based upon the document storage structure or even storage engine.
Conclusion
The biggest advantage of what I have elaborated is that we can effectively simulate a two-phase commit among multiple resources without the overhead of a 2PC. These allows us to use storage engines whose drivers don’t support two-phase, e.g. MySQL, PostgresSQL, or virtually all NoSQL implementations. Furthermore the receipt and publishing of a message is still transactional, it’s just a separate transaction from the storage of application state. As I mentioned previously those that do event sourcing effectively get this for free, but a small amount of application service code must be written to facilitate it.
One big argument against the above is that we’re doing lots of unneeded queries to determine if we should even bother to process the m! essage. Yes, that’s true, but we should only ever be querying a local storage (truly local or inside of our cluster). [UPDATE: The previous argument is nullified by using optimistic concurrency as noted in the previous UPDATE above.] Next, we don’t need to implement this for every message type. You are free to make your messages inherently idempotent. You are also free to use safe, slow two-phase commit if the situation requires or operational environment allows.
These same patterns can be applied even when using non-transactional resources, such as sending an email. The only quirk here is that there may be a one in a million scenario where we publish the same email twice. But in that case, it’s not really a big deal if someone gets duplicate emails.
Their argument: Other letter grades — A, B, C and D — are broken down in increments of 10 from 60 to 100, but there is a 59-point spread between D and F, a gap that can often make it mathematically impossible for some failing students to ever catch up.
I'm building a pair of Ubuntu systems for kids. For a variety of reasons, including lack of time and hardware problems, this has taken far longer than expected and I ended up with one running 9.10 (Karmic Koala) and the other 10.04 (Lucid Lynx). Since the Karmic system has the most testing effort into it (reviewing games for stability and kid appropriateness) I needed a way to duplicate the selection of games on the Lucid system while filtering out everything else since some packages are release-specific.
Using Synaptic it is possible to export (File > Save Markings) either a list of packages that have changed selection state but the changes haven't been applied yet or optionally a list of all packages and their status. While Synaptic can filter displayed packages by repository or type (the "section" parameter in the deb INFO file), these have no effect on the markings export.
The apt-get co! mmand (or dpkg directly) can be used to create a full list of packages but to produce a filtered list you need to use aptitude.
Aptitude has a search function that can be used to filter based on almost anything in a deb package INFO file. For example, to get a list of games available and save it to a game_selections.txt file:
aptitude search '?section(games)' >game_selections.txtThe question marks in the search pattern indicate that a search term follows. Because the parenthesis are special characters to the shell they need to have quotes around them. In this example "section" indicates the section parameter and "games" is term that is being searched for. Any package with a section parameter set to "games" will be listed:
...
i chromium-bsu - fast paced, arcade-style, scrolling space
i A chromium-bsu-data - data p! ack for the Chromium B.S.U. game
p chromium-data - t! ransitio nal dummy package for chromium-bs
p circuslinux - The clowns are trying to pop balloons to score points!
p circuslinux-data - data files for circuslinux
...
The leading character indicates it's state with "i" for installed, "i A" for automatically installed (either recommended or a dependency), and "p" for purged (i.e. no trace of existence on system which is the default state of all packages). To filter for installed packages only you add the "?install" parameter:
aptitude search '?section(games) ?installed' >game_selections.txt
...
i chromium-bsu - fast paced, arcade-style, scrolling space shooter
i A chromium-bsu-data - data pack for the Chromium B.S.U. game
i glchess - Chess strategy game
i glines - Five or More puzzle game
i gnect - Four in a Row strategy game
i gnibbles - Worm arcade game
i gnobots2 - Avoid robot! s game
i gnome-blackjack - Blackjack casino card game
...
The status and descriptions will cause syntax errors when using the file as input to aptitude so a format needs to be specified to filter them out. The "-F" parameter is used to indicate a format change and "%p" equates to the package name:
aptitude search -F '%p' '?section(games) ?installed' >game_selections.txt
...
chromium-bsu
chromium-bsu-data
glchess
glines
gnect
gnibbles
gnobots2
gnome-blackjack
...
To use game_selections.txt as input to aptitude on another system just use command substitution (see the sh or bash man page) to redirect it from the shell:
aptitude install $(< game_selections.txt)On Ubuntu you need to use sudo in front of this command or use "sudo su" to create a root shell and issue it from there.
The simplest quadratics to solve are ones like: x2 = A - there are said "to have no linear term" meaning that there is no term that is just "x." In these cases, the answer can be obviously found by applying our rule of "doing whatever we need to do to get the unknown by itself" In this case, simply taking the square root of both sides.
Thus, the negative of the solution we originally found is also a solution! So, we need to ! write, for completeness, that x = +/- Sqrt(A). However, the situation in physics (as opposed to mathematics) is made simpler by the fact that we are usually trying to solve for some physical value that has to make sense. If, for example, we are trying to find the time a ball lands after being dropped at time t=0, a negative answer will make absolutely no sense - so we know that we only need the positive answer. If instead, we were looking at a ball that was thrown upwards and we observed that at t=0, it was momentarily at rest (at the top of it's flight) and we wnated to infer the time it was thrown upwards (a question that is solved with exactly the same equation as the previous one) we know that the time we want must be negative, so we take that solution.
Secondly, there is a further complication if A is not a positive number - for as we all know, the square root of a negative number is not a real number - it is an imaginary one! It is important to think about whet! her an imaginary solution makes any sense at all - in a proble! m like t hose above, getting imaginary times makes no sense - either we have made a mistake, or there are simply no times where what ever we were looking for happened - in this case we say that there are "no solutions" (as opposed to saying that there are "imaginary solutions" when such solutions make sense).
The more general quadratic equations – the ones involving an "x" term as well as an "x^2" term are slightly more complicated to solve. There are two main ways of solving these equations – factorizing or using the "quadratic formula."
Then, if we have the equation
then the equation becomes:
Similarly, it is clear that x=-2 is also a solution.
In general, if we have an equation of the form,
Then we can rewrite this as
and then factorizing
and x = -D and -E
where
In all cases, it is possible to factorize the equation in this way. However, in many cases, the required D and E are difficult to find from simply looking at the equation (that is how I found the 1 and 2 in the numerical example above.
There are two cases where the factorization is especially easy – they are known as “difference of two squares” and “perfect square.”
We can also find this by factorizing the equation – we need to find two numbers that add to give zero and multiply to give c
It is clear that the only answer is:
The perfect square.
Consider the quadratic equation that is factorized to give
Multiplying this out, we get:
In many cases, the fact that this is a double solution (rather than a single solution) is usually unimportant – if you are trying to find a solution! , then your situation is even easier – there is only one choice!
The Quadratic Formula.
Although every quadratic can be factorized (as long as you are ok with imaginary and complex solutions), it is generally hard to find the factorization by simple inspection of the equation. Fortunately, we have an expression that gives the solutions to any quadratic equation.
This expression gives the answer to any quadratic equation. It is important to consider the possible types of solutions.
There are three distinct possibilities, each based on the value of the discriminant: b2 – 4ac. This value can be positive, negative or zero, giving distinct types of solutions to the quadratic equation (assuming a, b and c are all real numbers).
1) Positive Discriminant: In this case, the square root gives a real value. Then the plus or minus in fr! ont of it gives you two distinct solutions to quadratic equati! ons.2) Zero Discriminant: In this case, we have only one solution. The equation is a perfect square.
3) Negative Discriminant: When we take the square root of a negative, we get imaginary solutions. This leads to a pair of solutions that have the same real part and imaginary parts of opposite sign – complex conjugate solutions.
A. The subjunctive form of a verb is used following verbs or adjectives of urgenc
y, 
obligation or advisability. Write the words below under the correct column.
