text:
Ever since Bo Ryan became the head coach at Wisconsin back in 2001, the same things have been said about his Badgers teams on a yearly basis. "Oh they are a solid team, but their style will never translate well come tournament time". "Will this be the year they finally make a deep run in the NCAA tournament?" "Bo Ryan's system will not allow them to ever get very far in the tournament until his staff starts recruiting better athletes". These are just some examples of the various statements made about Bo Ryan's Wisconsin Badgers teams. I'll bet he is as tired of listening to them as we all are of saying them. Well Bo, if you are tired of listening to them, then do something about it. It took over a decade, but for the first time ever, he finally did something about it.
The Wisconsin Badgers will be making their first ever trip to the Final Four this weekend under Bo Ryan when they travel to Dallas along with Connecticut, Kentucky, and Florida. I for one had Connecticut losing in the first round. Oops.
I could sit here for the 48th time and tell you the strengths and weaknesses of this team- strength: best starting five in America, weakness: Absolutely no bench to speak of. But that would be a waste of time as you know that already. I will say this. Yes Wisconsin does deserve credit for making this run, but they also got very, very lucky. They were placed as a two seed in what was by far the weakest of the four regions. The number one in that region, Arizona, was going in reverse towards the end of the season. Yet again on Saturday, they will get lucky. They will get an inconsistent Kentucky team instead of say Wichita State, Louisville, Duke, or Michigan.
Let's not dwell on that though. Right now, Bo Ryan should enjoy this moment. This moment is pure vindication for a man who has done something he has been told for over a decade he could not do, and for that, I say congratulations, you proved me and everyone else who said that to be wrong. Well done.


text:
Creating a Focal Point
Each card needs a focal point—it's the part of the card that catches the recipient's eye first.
The focal point is often an image or an embellishment, like a stamped sentiment, a silk flower, a Dazzles™ sticker or a greeting. It's sometimes (but not always) the largest or brightest element on the card. The focal point can be placed in the center of the card, or off-set to one side.
A card greeting is a great focal! Use the 1000 Card Quotes or the Card Greetings & Sentiments CD to find the perfect message for your card.
And while many focal points consist of one image or embellishment, you can also group an uneven number of smaller accents together to create a single focal. Choose 3, 5 or (if the items are small or you have a large card) 7—the uneven number is a graphic design element that works beautifully in card making. Group the items close together or even overlapping so they easily create a single unit. The items don't have to be the same…you could combine a small tag with a silk flower and a brad.
A focal point can also be a technique, like a unique flap or closure, or a window cut in the card front. And sometimes a focal point isn't even an element of the card, it's the shape of the card itself!

subset: commoncrawl


text:
Landon Donovan couldn't make it back from his sprained ankle, but the LA Galaxy were just fine without him Wednesday night. They put Cartaginés away in the first half-hour, cruising into the CONCACAF Champions League knockout stage with a 3-0 victory in San Jose, Costa Rica.
Jack McBean nodded the Galaxy ahead in the sixth minute, Chandler Hoffman netted his first pro goal in the 18th, and Laurent Courtois scored another beauty in the 29th as Bruce Arena's reserve lineup schooled the Costa Ricans in its most complete performance of the tournament, posting the team's third successive CCL shutout.
The Galaxy needed just a draw to win Group 8 and claim their third successive CCL quarterfinal berth. They're the second team to win a spot in next year's knockout phase – Club Tijuana won Group 7 last week – and join Cruz Azul and Toluca as the only 3-0-0 sides in the competition. Cartaginés finished the tournament with a 1-2-1 record.
The result makes academic LA's last group stage game, Oct. 24 at El Salvador's Isidro Metapán (0-2-1), enabling them to focus entirely on their MLS regular-season finale three days later at Seattle, a match that could have huge implications on the Western Conference playoff race.
Donovan, sidelined since spraining his left ankle a week and a half ago, traveled to Costa Rica but didn't make the starting XI nor the bench in what the club called a game-time decision. Arena teamed McBean and Hoffman up top, gave Colin Clark his first CCL appearance for LA, used Pablo Mastroeni in central defense (with Kofi Opare suspended), and used rookie Homegrown Player Oscar Sorto, making his competitive debut, at right back.
The Galaxy were in charge from the start, with Michael Stephens and McBean driving forces behind their attack in the opening minutes.
The teen McBean, who scored three goals in last year's CCL group stage, provided the early lead from a free kick he won just to the right of Cartaginés' box. Rafael Garcia chipped in a short cross into the middle, and McBean beat Andrés Flores to powerfully head it past goalkeeper Luis Torres.
LA doubled their lead six minutes after that with a superb sequence. McBean, on the right flank, held off two defenders and then split them with a little pass to Stephens, who whipped a ball into the goalmouth. Hoffman, who made his competitive debut for LA in last week's CCL victory over Metapan, took a subtle touch to redirect the ball into the net.
The Galaxy erased any remaining doubt in the 29th minute, when a loose ball came to Courtois about a dozen yards outside Cartaginés' box. He stepped forward into open space, then ripped a left-footed shot past a diving Torres on the bounce and into the right-side netting.
Cartaginés had nearly a half-dozen opportunities in the final 20 minutes, but just three on frame: Free kicks by former Galaxy midfielder Paolo Cardozo in the 71st minute and Leandro Silva 10 minutes later, both snagged by Brian Rowe, and a Pablo Herrera's rocket from the right side that Rowe tipped over the bar in the 86th.
The Galaxy, fourth in the West, return to MLS action Saturday night at third-place Portland.
LA Galaxy 3, CS Cartagines 0
Wednesday, September 25, 2013
Estadio Nacional – San Jose, Costa Rica
CONCACAF Champions League – Group Stage – Week Five
Scoring Summary:
LA – Jack McBean 1 6'
LA – Chandler Hoffman 1 18'
LA – Laurent Courtois 2 29'
Misconduct Summary:
CSC – Pablo Herrera (Yellow Card) 63'
LA – Rafael Garcia (Yellow Card) 72'
CSC – Danny Fonseca (Yellow Card) 78'
LA Galaxy: Brian Rowe; Oscar Sorto, Tommy Meyer, Pablo Mastroeni©, Greg Cochrane; Rafael Garcia, Michael Stephens, Laurent Courtois (Marcelo Sarvas 77'), Colin Clark (Gyasi Zardes 82'); Chandler Hoffman, Jack McBean (Jose Villarreal 90').
Subs Not Used: Brian Perk, Leonardo, Sean Franklin, Hector Jimenez.
CS Cartagines: Luis Torres; Andres Flores, Carlos Johnson©, Andres Sanabria, Esteban Sirias; Eduardo Valverde (Erick Scott 34'), Danny Fonseca, Pablo Herrera, Paolo Cardozo (Leandro Silva 79'), Paolo Jimenez (Brayan Lopez 66'); Randall Brenes.
Subs Not Used: Wardy Alfaro, Giovanni Clunie, Felix Montoya, Randall Alvarado.
Referee: John Pitti (PAN)
Referee's Assistants: Daniel Williamson (PAN) and Rey Mendoza (PAN)
4th Official: Roberto Moreno (PAN)
Attendance: N/A


text:
This section lists a number of miscellaneous tips for improving query processing speed:
Use persistent connections to the database to avoid connection overhead. If you
cannot use persistent connections and you are initiating many new connections to the database, you may
want to change the value of the
thread_cache_size variable. See Section
8.11.2, "Tuning Server Parameters".
Always check whether all your queries really use the indexes that you have created
in the tables. In MySQL, you can do this with the
EXPLAIN statement. See Section
8.8.1, "Optimizing Queries with
Try to avoid complex
SELECT queries on
MyISAM tables that are
updated frequently, to avoid problems with table locking that occur due to contention between readers
and writers.
MyISAM supports concurrent inserts: If a table has no
free blocks in the middle of the data file, you can
INSERT new rows into it at the same time that other threads are
reading from the table. If it is important to be able to do this, consider using the table in ways that
avoid deleting rows. Another possibility is to run
OPTIMIZE TABLE to defragment the table after you have deleted a lot
of rows from it. This behavior is altered by setting the
concurrent_insert variable. You can force new rows to be appended
(and therefore permit concurrent inserts), even in tables that have deleted rows. See Section
8.10.3, "Concurrent Inserts".
To fix any compression issues that may have occurred with
tables, you can use
TABLE. See Section 14.6, "The
ARCHIVE Storage Engine".
ALTER TABLE ... ORDER BY if you usually retrieve rows in
expr2, ...
order. By using this option after extensive
changes to the table, you may be able to get higher performance.
expr2, ...
In some cases, it may make sense to introduce a column that is "hashed" based on information from other columns. If this column is short, reasonably unique, and indexed, it may be much faster than a "wide" index on many columns. In MySQL, it is very easy to use this extra column:
col2)) AND
constant' AND
MyISAM tables that change frequently, try to avoid
all variable-length columns (
BLOB, and
TEXT). The table uses dynamic row format if it includes even a single
variable-length column. See Chapter 14, Storage
It is normally not useful to split a table into different tables just because the
rows become large. In accessing a row, the biggest performance hit is the disk seek needed to find the
first byte of the row. After finding the data, most modern disks can read the entire row fast enough for
most applications. The only cases where splitting up a table makes an appreciable difference is if it is
MyISAM table using dynamic row format that you can change to a fixed row
size, or if you very often need to scan the table but do not need most of the columns. See Chapter 14, Storage
If you often need to calculate results such as counts based on information from a lot of rows, it may be preferable to introduce a new table and update the counter in real time. An update of the following form is very fast:
count_col+1 WHERE
This is very important when you use MySQL storage engines such as
MyISAM that has only table-level locking (multiple readers with single
writers). This also gives better performance with most database systems, because the row locking
manager in this case has less to do.
If you need to collect statistics from large log tables, use summary tables instead of scanning the entire log table. Maintaining the summaries should be much faster than trying to calculate statistics "live." Regenerating new summary tables from the logs when things change (depending on business decisions) is faster than changing the running application.
If possible, classify reports as "live" or as "statistical," where data needed for statistical reports is created only from summary tables that are generated periodically from the live data.
Take advantage of the fact that columns have default values. Insert values explicitly only when the value to be inserted differs from the default. This reduces the parsing that MySQL must do and improves the insert speed.
In some cases, it is convenient to pack and store data into a
BLOB column. In this case, you must provide code in your application to
pack and unpack information, but this may save a lot of accesses at some stage. This is practical when
you have data that does not conform well to a rows-and-columns table structure.
Normally, try to keep all data nonredundant (observing what is referred to in database theory as third normal form). However, there may be situations in which it can be advantageous to duplicate information or create summary tables to gain more speed.
Stored routines or UDFs (user-defined functions) may be a good way to gain performance for some tasks. See Section 18.2, "Using Stored Routines (Procedures and Functions)", and Section 22.3, "Adding New Functions to MySQL", for more information.
You can increase performance by caching queries or answers in your application and then executing many inserts or updates together. If your database system supports table locks (as does MySQL), this should help to ensure that the index cache is only flushed once after all updates. You can also take advantage of MySQL's query cache to achieve similar results; see Section 8.9.3, "The MySQL Query Cache".
Use multiple-row
INSERT statements to store many rows with one SQL statement. (This is a
relatively portable technique.)
INFILE to load large amounts of data. This is faster than using
INSERT statements.
AUTO_INCREMENT columns so that each row in a table
can be identified by a single unique value.
TABLE once in a while to avoid fragmentation with dynamic-format
MyISAM tables. See Section
14.3.3, "
MyISAM Table Storage Formats".
MEMORY tables when possible to get more speed. See
Section 14.4, "The
Storage Engine".
MEMORY tables are useful for noncritical data that
is accessed often, such as information about the last displayed banner for users who don't have cookies
enabled in their Web browser. User sessions are another alternative available in many Web application
environments for handling volatile state data.
With Web servers, images and other binary assets should normally be stored as files. That is, store only a reference to the file rather than the file itself in the database. Most Web servers are better at caching files than database contents, so using files is generally faster.
Columns with identical information in different tables should be declared to have identical data types so that joins based on the corresponding columns will be faster.
Try to keep column names simple. For example, in a table named
customer, use a column name of
name instead of
customer_name. To make your names portable to other SQL servers, consider
keeping them shorter than 18 characters.
If you need really high speed, look at the low-level interfaces for data storage
that the different SQL servers support. For example, by accessing the MySQL
MyISAM storage engine directly, you could get a speed increase of two to
five times compared to using the SQL interface. To be able to do this, the data must be on the same
server as the application, and usually it should only be accessed by one process (because external file
locking is really slow). One could eliminate these problems by introducing low-level
MyISAM commands in the MySQL server (this could be one easy way to get
more performance if needed). By carefully designing the database interface, it should be quite easy to
support this type of optimization.
If you are using numeric data, it is faster in many cases to access information from a database (using a live connection) than to access a text file. Information in the database is likely to be stored in a more compact format than in the text file, so accessing it involves fewer disk accesses. You also save code in your application because you need not parse your text files to find line and column boundaries.
Replication can provide a performance benefit for some operations. You can distribute client retrievals among replication servers to split up the load. To avoid slowing down the master while making backups, you can make backups using a slave server. See Chapter 16, Replication.
Declaring a
MyISAM table with the
DELAY_KEY_WRITE=1 table option makes index updates faster because they are
not flushed to disk until the table is closed. The downside is that if something kills the server while
such a table is open, you must ensure that the table is okay by running the server with the
--myisam-recover-options option, or by running myisamchk before restarting the server. (However,
even in this case, you should not lose anything by using
because the key information can always be generated from the data rows.)
LOW_PRIORITY for supported nontransactional tables when you want to give
SELECT statements higher priority than your inserts.
HIGH_PRIORITY for supported nontransactional tables to get retrievals that jump the queue.
That is, the
SELECT is executed even if there is another client waiting to do a
LOW_PRIORITY and
HIGH_PRIORITY have an
effect only for nontransactional storage engines that use only table-level locking.