text:
posted by Chase .
Is it possible for companies both to maximize financial value for shareholders and to act responsibly in the communities in which they operate, to treat their employees, customers, and suppliers well, and to engage in activities that are good for the environment? In your response, please cite examples of companies that are doing so.


text:
Faculty Grants Committee
About us
The Faculty grants Committee is responsible for evaluating applications from faculty for internal grant funding at Millersville University to support research, publications, travel to present, special academic activities, and released time.
The committee consists of ten faculty members, who read and individually rank each proposal. Proposals are scored on a 10 point scale and a trimmed mean is computed by eliminating each proposal's highest and lowest score. The committee allocates funding to proposals using a blind review of trimmed mean scores.
Regular faculty (tenured and tenure track), temporary full-time (TFTF) and regular part-time (RPT) faculty are eligible to apply for all categories of faculty grants, with the following exception: only regular faculty (tenured and tenure track) are eligible to apply for Released Time grants.
General Guidelines
- All of your application materials in a single PDF file for each proposal must be submitted via email to the chair at email@example.com on or before the submission deadline. Incomplete applications will not be considered.
- Proposals must be typewritten in standard English, avoiding professional jargon. They should be comprehensible to any member of the committee regardless of his or her discipline.
- It is permissible to apply one cycle in advance for activities (e.g., apply in the summer cycle for a fall activity). It is not permissible, however, to apply retroactively (e.g., you may not apply in the fall to fund activities that took place in the summer). You may not apply for the same activity in multiple cycles.
- All activities and/or presentations for the same conferences will be considered under only one academic application and category (e.g. Travel-to-Present or Special Academic Activities), so please use only one application.
- Organizational membership fees will not be paid through Faculty Grants monies. Please do not include such fees in registration requests.
- Members of the Faculty Grants Committee are eligible to submit proposals for all grant categories but will not evaluate their own proposals or participate in discussions of their proposals.
- Final report forms must be submitted one year from date of award for recipients of research grants, publication grants, and released time grants. (Reports are not necessary for travel grants or special academic activities).
Submission Deadlines
Submission Deadlines for Grant Cycles
- Fall Cycle: October 1
(Activities from Sept. 1 - Dec. 31)
- Spring Cycle: March 1
(Activities from Jan. 1 - May 31)
- Summer Cycle: June 1
(Activities from June 1 - Aug. 31)
Note: If the 1st falls on a weekend, the deadline is moved to the following Monday
All grant proposals must be received by 5:00 p.m. on submission deadline. Requests for extensions will not be honored.
Contact the Chair
Dr. Kerrie Farkas
Location: Chryst Hall
Phone: (717) 871-7399
Email: firstname.lastname@example.com
Committee Members
- Dr. Jeff Adams
- Dr. Sarah Brooks
- Dr. Kerri Farkas
- Dr. Ronald Frankum
- Dr. Justin Garcia
- Dr. Christine Gaudry
- Prof. Krista Higham
- Dr. Maria Schiza
- Dr. Jennifer Shettel
- Dr. Mingquan Zhan

subset: commoncrawl


text:
The 15th Annual Cooper Open will he held on October 8th, 2016 at the br>Breakfast Hill Golf Club 339 Breakfast Hill Road, Greenland, NH 03840
Four Person Scramble will have a shotgun starting at 11A.M. all registrations must be in by 10A.M.
Name: Christopher White
Address: 47 Shrewsbury Ave
Highlands, NJ 07732
Telephone: +732-547-3509
E-mail: firstname.lastname@example.com


text:
The 2009 host reportedly is invited back to host the awards show's ceremony which will be held this June.
Neil Patrick Harris continued to be a coveted host and performer at awards shows. A report emerged a day after the 65th Tony Awards nominations were announced that the actor is hired to host the awards-giving show once again.
Harris hosted Tonys in 2009 and did such an impressive job that he was tapped to host the Emmys that year. From there, he went on performing a musical number at the 82nd Academy Awards and hosting 2010 Spike's Video Game Awards.
Harris' stint for this year's Tonys is yet made official. Deadline said his position as the one of the stars in CBS' juggernaut "How I Met Your Mother" definitely is an added value. Beside, last year's host Sean Hayes would be occupied with his starring role in "The Three Stooges" movie.
The 65th Annual Tony Awards will be held on June 12 to recognize achievement in Broadway productions during the 2010-2011 season. They will be held at the Beacon Theatre, ending a fourteen-year tradition of holding the ceremony at Radio City Music Hall.


text:
Tuesday April 16th, 2013 - 10:24AM
WARSAW, POLAND—Over the next few years, 23 new hotels with 5,200 rooms will open their doors in Poland, according to a hotel market report published by TOPHOTELPROJECTS.
Poland's market leader is the hotel chain Orbis, belonging to Accor, with 54 properties (10,610 rooms). Last year, Orbis opened six new hotels (775 rooms).
Hilton is currently developing three properties for its Doubletree by Hilton brand, two Hampton by Hilton hotels, one Hilton Garden Inn and a large Hilton Hotel in Poland. Hilton currently operates five hotels in Poland. In addition, Marriott is currently constructing a Courtyard by Marriott and a Renaissance Hotel. The Louvre Hotels Group is currently developing two Golden Tulip Hotels and Starwood Hotels is scheduled to open a Sheraton Resort.
According to the report, Poland is under-saturated in the budget and low budget segment; German budget design hotel chain Motel One is planning for a property in Warsaw with roughly 180 rooms, and is looking for a fitting location in Krakow.


text:
The technique involves leverages the fact that tables and rows are really just subforms with special attributes. So when designing the form, we create:
And then to turn this into a table, add this initialization script to the table subform:
// mark this subform as a table this.layout = "table"; /**
* if needed, we could explicitly set the column widths * If left alone, the columns will be auto-sized */ //this.columnWidths = "1in 2in 2in 2in 1in";
And then for each row in the table, add this initialization script:
// mark this subform as a row this.layout = "row"; if (this.instanceIndex === 0) { // mark the first row as a header this.assist.role="TH"; } else { // mark each subsequent row as a regular table row this.assist.role="TR"; }
Note that setting the role attribute is very important for accessibility — it allows the screen reader to use the table header cells to describe the contents of the table body cells. Here is a sample form that implements this technique — along with sample data for previewing.]]>
Fix Layout Problems using XFADebugger
The purpose of this exercise is to fix layout problems by analyzing their PDF with XFADebugger.pdf.
In Designer, open: EX4 LayoutProblem.pdf (with preview data file: afiList.xml)
In preview, notice that :
Open XFADebugger.pdf in Acrobat. Use the "Load XFA/PDF file" to open EX4 LayoutProblem.pdf.
Here is the file with the layout problems fixed: EX4 LayoutProblem (Solution).pdf]]>
Create a shared script object fragment
Open the file: EX3 addressCopy.pdf in Designer
Preview the file with sample data and note the behavior when you check "same as billing". The shipping address values are greyed out and the values are synchronized with the billing address.
The Exercise:
Bonus 1:
Bonus 2:
Solution: EX3 addressCopy (Solution).pdf
Implement Field Validation
Open EX2 Validation.pdf in Designer
The solution file is: EX2 Validation (Solution).pdf
Reverting changes to fields:
To write re-usable code for changing values back to their original state, we should never hard-code the changes. E.g. we should never revert a color by writing: Field.fillColor = "255,255,255". The original color may not have been white.
Rather, after modifying an element, we can revert by removing the changed element. Removing an element forces the XFA processor to use the original value found in the form template.
E.g. Change the font color by modifying the font.fill.color element:
Field.font.fill.color.value = "255,0,0";
Revert the change by removing the color element:
Or by removing one of the ancestor properties:
Changing/filtering keystrokes
xfa.event.change = xfa.event.change.toUpperCase();
We did a pre-conference lab on LiveCycle best practices. For the lab I prepared four exercises on various aspects of form design. For those who weren't able to attend, I'll post those exercises as a series of blog entries.
Exercise #1: Measure and Improve JavaScript Performance
In this exercise we optimized a fairly simple script – a few lines in a loop. Depending on your machine, you should be able to improve the performance anywhere from a factor of three up to a factor of seven.
Open EX1 Performance Tests.pdf in Designer.
There are 50 subtotal values that need to be totaled. Each total has a test button that executes the Total script 500 times and measures the performance.
Note the 4 variations of the sum function:
Understanding the solution:
Why is FormCalc faster?
All references to XFA objects from JavaScript involve a round-trip from the script environment to the XFA processor and back. These round trips are expensive.
FormCalc runs native in the XFA processor and there are no round-tripping costs.
Today's sample has an image field with a validation script that checks the size of the loaded image. For an image field, field.rawValue will return the base64 value of the embedded image. The length of that string will tell you how big the image is. My validation script does a rough conversion — image size is roughly 3/4 the size of the base64 string. If that size is greater than your threshold you can choose to either reject the image (set the field to null) or simply mark the field as invalid.]]>
Then, one of our own, Ragavendra, has a blog focused on the server side of forms and output:
http://blogs.adobe.com/foxes/ . In particular, you might find this entry interesting:
With the latest verson of ADEP, it is now possible to create bookmark references for your dynamic forms.
But today the focus is on some things to get you further ahead with macros.
Updated Samples
I've included a zip file with the following:
You can simply unzip this file under your Designer install directory and they should immediately work.
If you're writing new macros, you should appreciate sample.js. It includes:
Have a peek at the comments in the macro for more details.
In full disclosure, I admit that one of the reasons for updating these macros is that I found a couple issues where old macros didn't work in the new version of Designer. But not to worry, there are workarounds available and the new versions of these macros work even better than the old ones.
Not surprisingly, I use Dreamweaver to edit my macro javascript files. It is possible to extend the object assist/hinting mechanism of Dreamweaver. Take this designer.xml and place it under the Dreamweaver/configuration/CodeHints directory. Then, next time you start DW, you will have code hinting for the designer object.
I'd like to extend this to more of the XFA object model, but that's a project for another day.]]>
You can find the online documentation here.
The good news is that the macros you wrote for ES2 should continue to work in the new Designer. The only changes is that we've changed the directory name where they're stored (now under "macros"). As well, each macro is described by a macro.xml file.
There are a couple items I should hightlight:
There is a method: designer.callExternalFunction() that allows you to call an arbitrary method in a .DLL. Here is your escape key for every integration problem you might conceive.
designer.filterNodeTree() is added to enhance performance. Traversing the entire DOM searching for specific elements can ge slow on large forms. For example,
designer.filterNodeTree(xfa.template, "className", "font") will return all the <font> elements in the form.
designer.filterNodeTree(xfa.template, "name", "price") will return all the objects named "price".
If you produce .chm help files to document your macro, you can invoke them with designer.showHelp()
And, just to give you an excuse to try this out, I've written a new macro. This one will append a floating field reference for an existing field to a text object. Here are the macro.xml and javascript files. Usage: select the text and field objects, then invoke the macro.


text:
TAS Market Profile Review
In our TAS Market Profile Review we're going to discuss the pros and cons of this advanced technical indicator. This is an update to the review written by Ross in 2014. You can see his original review by clicking here. New traders are often faced with so many choices when choosing different trading technologies, it can be daunting and discouraging, not to mention expensive. Fortunately, if you are like most people, you turn to trusted review sites to help guide your decision making process. Not all tools are right for all types of traders. But, in the case of the TAS indicators, there is a little something for everyone. TAS provides a suite of 7 high tech and proprietary indicators that compliment your regular charting software.
TAS Market Profile Indicators
Part of TAS offerings include the TAS Scanner. This unique tool allows you to see stocks moving in different time frames with varying levels of buying or selling confidence at key levels. Of the 7 different charting indicators however, my three favorite are the TAS Market Map, TAS Vega and TAS Boxes.
TAS Market Map – "delivers a visually-appealing Market Profile layover that reveals volume gaps, congestion and breakout trades."
TAS Boxes – "expose the fair auction supply and demand value areas. Trade in breakout mode when outside of these levels or play the range inside them."
TAS Vega – "powers up your price bars in REAL-TIME by replacing traditional coloring with TAS directional bias cues (green = bullish, red = bearish).
Some Pros and Cons
– Can be very accurate in many different types of markets, performs better with liquidity.
– Top notch customer service
– Ability to use the same tools as institutional traders
– Advanced scanning tools
– Robust educational center
– Works with several different market types and instruments
– Expensive for new traders looking to minimize overhead
– Can be complex to setup and understand, there is a slight learning curve
– May not work with every trader's style, but can be adapted for most
Summary of TAS Market Profile
In summary, there is no silver bullet when it comes to trading. Most traders will learn early on, that there is no such thing as a one size fits all, tool of all tools to simply print money. So, finding that balance between the right combination of tools and overhead cost is critical. TAS Market Profile fills a unique role for traders who are looking to pay a little money to avoid having to do a bunch of heavy lifting. I have been using TAS indicators for a couple years now and would hate to even imagine what trading without them would be like. As with anything, make use of the free educational tools that accompany the products, so that you can get the most out of them.


text:
All aglow, but we can't show you the teeth
Page Tools
The hair, well, the hair's not so good: it's all poncy and puffy so I look like a cross between a mad scientist and the bass player from Air Supply. And the neck, well, the neck's not so good either; it's all short and stumpy, with so many neck folds, when I tilt my head downwards, I've got 18 smiles perched on top of each other. And the eyes, well the eyes are completely shocking; they're so squinty and short-sighted, I can't see a thing without my glasses - a few months ago I accidentally brushed my teeth with Rectinol, and I don't want to tell you what I did with the toothpaste, but I've never felt so fresh and minty there before.
Yep, my face is a total mess, it's malformed, inadequate and dysfunctional. But I do have one half-decent face part that makes up for all the rest, and I'm talking about my teeth. I've got great teeth, AMAZING teeth: they're clean and unchipped and perfectly spaced - when I smile it's like staring at a sparkling new white mouthguard with teeth-lines drawn on using a set square.
I'VE GOT THE FINEST TEETH IN ALL THE LAND, well, that's what I thought until a couple of weeks back when I was in the kitchen having a chat with my beloved - I think I was explaining the advantages of wiping up milk with the scourer side of the sponge as opposed to the spongy side, really fascinating stuff - and then suddenly she looked at me and said "You know Danny, I think your teeth are getting a bit ... yellow." My stomach flipped, my head spun: I ran to the bathroom, looked in the mirror, and sure enough, my teeth WERE yellow - they were like two rows of lolly bananas, but unchipped and perfectly spaced.
Years of coffee-drinking and chocolate-eating and Rectinol-brushing had clearly taken their toll - not to mention the fact that I hadn't been to the dentist since the New Romantic pop-synth movement. I panicked: I thought to myself, okay Danny, your teeth are your most precious asset so you've got to be sensible about this - you could either go to the dentist and have them cleaned professionally ... or you could buy that cheap tooth-whitening stuff you saw advertised on late night TV that whitens your teeth in 14 days or your money back.
So I rushed off to the chemist and bought the tooth-whitening stuff: it came in a little bottle with a brush stuck in the lid - I think it was just repackaged liquid paper, and it tasted like it too. I put it on every day for the next 14 days but nothing happened - no change, the teeth stayed yellow. I started putting it on TWICE a day, slapping on thick coats like I was painting a fence - still nothing. I put it on THREE times a day, once between each meal - NOTHING WAS HAPPENING. Twenty-two days later, I was lying in bed with my beloved: we'd turned out the lights, it was all dark, and we were having a chat - I was telling her how sometimes at night I like to secretly wriggle my fingers under my pillow and that made me happy because I knew nobody in the world could see me doing it, really fascinating stuff - and suddenly she said to me, "You know, Danny, I think your teeth are ... glowing."
It was true: my teeth were lighting up the room - I could actually see her face in the dark, like I had a mouthful of those fluorescent sticks that you crack open when you go fishing. MY TEETH WERE RADIANT: if I opened and closed my mouth really fast, it was like being on the dance floor at Revolver.
I don't know what was in this whitening stuff, but I knew I had to stop using it immediately, so I haven't used it since: I'm going to let my teeth stay yellow, try and get my money back and hope that one day this glow goes away. And, meantime, if I sleep with my mouth open, my beloved can read books in the dark.


text: Democratic Women's Summit offers hope for aspiring officials By Ernest Luning on November 11, 2011 Women politicians face some of the same barriers that seemed outmoded decades ago, but it's more important than ever to make sure women are well represented in government because of their unique perspective and, studies show, they make better lawmakers. That was the message delivered to a group of nearly 100 women who gathered all […]This content is only available to subscribers. Login or Subscribe Share this:EmailTwitterFacebook Current News, Ernest Luning, The Colorado Statesman, Title Item


text:
Join as a member. There's a certificate with your name on it.
- Too many things are called "language". That's very confusing for someone changing or using the APIs.
- Use clearly and consistently separated names everywhere, by renaming some of the names.
$languageis a global object that contains "all details" for the (negotiated) language of the current request.
This global might go away with the D8 context initiative. But we need to have a name for it in the meantime.
$languageis a language identifier string in some locations. E.g., locale.module, locale.test, and some Field API functions.
$language->languageis a language code if
$languageis an object.
$langcodeis a language identifier string in most existing places.
Alternatives would be
$language_tag. But the variable name should ideally be identical to schema column names.
'language'is the language identifier string in database schema columns. E.g., {language}, {node}, {locales_target}, {date_format_locale}, etc.
$languageis a language object but not the global $language in some locations.
- Competitive analysis showed that most other frameworks call a language identifier "locale" -- which may be technically incorrect, since it is a "locale identifier" as well.
- The W3C calls language identifiers "language tags". This terminology could be easily confused with HTML tags.
- We need a proper analogy to the following pattern:
$uid => {language identifier} $user => {global language} $account => {a language}
as well as:
$account = user_load($uid); $language = language_load($language); $account = user_load($node->uid); $language = language_load($node->language);
- We need names for the following pieces of data:
- Language identifier
- Currently called $langcode, $language, $language->language, and $object->language in code, and always 'language' in the database schema. Has implications for most objects in Drupal; entities, fields, nodes, users, etc.
- Global language object
- Currently called $language. Prevents using $language with different meaning in the same local code scope.
- Language object
- Currently called $language. Too easily mistaken with global language object.
Proposed resolution
// Language code ('en', 'de', 'pt-br'): $node->langcode; // Loading language object (object based on {language} table columns by language code): $language = language_load($langcode); // Language code on various objects in Drupal: $language->langcode; $node->langcode; $user->langcode; // Language object for global consumption global $language_interface;
Related issues
#1215716: Introduce locale_language_save()
#1222194: Rename global $language to $language_interface
#1220964: Number field prefix/suffix get t()'ed through format_plural()
#1218650: Separate language and locale. Proper languages for content translation.
Some of these issues depend on the outcome of this discussion.
|Gábor Hojtsy
PASSED: [[SimpleTest]]: [MySQL] 33,545 pass(es). View
Comment #1Jose Reyero CreditAttribution: Jose Reyero commented
I'd suggest:
- $language for a language object
- $locale for a language code
Comment #2Jose Reyero CreditAttribution: Jose Reyero commented
On top of that two we could use a function to refer to global language object so it can take some parameters and return the right object on each case.
language(), global language object
So if we want to get the language code for the interface language it would be:
Comment #5sun CreditAttribution: sun commented
- $language for a language object
- $locale for a language code
Sorry, but that's completely off for me.
- Language means a spoken or written language (i18n).
- Locale summarizes many different aspects of localized formats (l10n); i.e., dates, numbers, currency, etc.
- Both have a language code. Whereas for Locale, the country part in a language code is more important (if any).
- A language code only means a string literal denoting a certain language name, as defined in ISO 639.
- Locale rules can be the same for multiple languages.
- A language can be the same for multiple countries and locales.
Thus, calling a language code "locale" is utterly wrong IMHO.
I'd agree however with renaming all instances of $language to $langcode where only a language code is passed. Especially Field API introduced lots of inconsistencies here.
Comment #8janusman CreditAttribution: janusman commented
IIUC this issue is mostly about Developer eXperience =)
I think sun is correct in that "locale" means a different thing than "language code". We should use "$langcode" arguments and local variables for cases when it means the ISO-????-compliant string for language. Maybe we should even call it $langcode_isoXYZ (I forget the ISO number for that) if that indeed is what it is, and to make the distinction between other common language code formats (like "es_ES").
Re: the column 'language' under the languages table... I lean towards renaming to "language_id" or "lid" (like we have nid and vid for node & taxonomy vocs.) as gábor mentions that it's just a way to identify a language object. However, we also have 'lid' in locales_source/target tables.
Comment #10kika CreditAttribution: kika commented
Both $langcode and $language_code make sense, the latter is longer but bearable.
Comment #11plach CreditAttribution: plach commented
If we limit this discussion strictly to the matter introduced by the OP, my suggestion to match the $uid, $user, $account pattern is to start using the name the w3c uses for language codes, i.e. language tags. We could then have a
tag column instead of the
language one. This would lead us to
$tag and
$language->tag. The global name clash is still there but, since language types are module definable, we could simply switch to an official
language_ prefix and have something like: $language_ui, $language_content, $language_url. To recap:
$uid, $user, account
$tag, $language_ui, $language
Anyway, I'd like to see us introducing (at least very basic) built-in locale support, and love to have a
$locale global allowing us to do something like:
Probably the WSSCI will need address this.
Comment #12plach CreditAttribution: plach commented
While working on translatble fields I always wondered if being able to store field languages as numeric language ids could boost performance: this might be another reason to introduce a
$languages.lid column, which would lead us to:
$uid, $name, $user, $account
$lid, $tag, $language_ui, $language
Btw, I think that the
{languages} table should be renamed to
{$language} for consistency.
Comment #15plach CreditAttribution: plach commented
Pretty hard to tell and a sizable patch to work on just to be able to tell the performance implications.... Hm.
Yes, the gain might not match the effort after all.
You suggest $langcode becomes $tag?
$language_tag which is one char shorter than
$language_code ;)
Comment #16sun CreditAttribution: sun commented
There are two factors that make the 'language' as integer abstraction obsolete (or not measurable):
- Field data is cached. We don't query/filter the data on most requests to begin with.
- The 'language' column is indexed, and there's only small amount of possible string values. Storage engines can make full use of the index, reducing result sets in no time.
I don't have exact numbers at hand, but you can try it out yourself: Insert one billion rows with a small variation of (short) 'language' values into a table and use a language in WHERE. Then update the data to add many arbitrary 'language' values -- at some point, the index will blow up and the WHERE reduction will resort to a filesort.
Comment #17plach CreditAttribution: plach commented
Ok, let's skip
lids then, what about
tags? ;)
@gabor (#14):
No code, just ideas like the one in #11, I can post an issue if you think this might fit into d8mi.
Comment #19Jose Reyero CreditAttribution: Jose Reyero commented
I tend to like the idea of having a $language object and a $locale object.
So, new suggestion:
$language_code for a variable containing a language code.
$language->code for the Language object's language code.
'language' for any other db field being a language code because it references that, a language.
Then there's the question of whether we would like to have different content for locale variations of languages or just for languages. Maybe life would be easier if we had both concepts clearly separated and:
- English content 'en'
- English/US interface language (locale, en_US)
Since we are reworking the whole thing, let's get it right.
Comment #20sun CreditAttribution: sun commented
Then there's the question of whether we would like to have different content for locale variations of languages or just for languages. Maybe life would be easier if we had both concepts clearly separated and:
- English content 'en'
Note that language codes including country also apply to content language -- for example, a content can be written in American English (en) and British English (en-gb). While that might sound edge-casey and nitpicky, I've seen some excellent sites in the wild that actually provide this.
Also note that, to my knowledge, the country extension is officially (as in RFC) separated with a hyphen, not a underscore.
Comment #21Jose Reyero CreditAttribution: Jose Reyero commented
Yes, that (American / British English) content may be a feature. Which would be nice if we could support the more usual case of having English content and American/British localized UI.
That is not the case though and it looks like we'd need to choose between both options.
Supporting edge cases is nice if you already support the most common ones.
(I've never seen such a site btw, nor Argentina/Spain Spanish content either).
Comment #22plach CreditAttribution: plach commented
I don't understand why
tag is not being even taken into consideration: it's the closest thing we have to a standard specification. The fact that most other platforms call it
locale does not sound as a compelling argument to me:
In this article we refer to the value of a language attribute such as fr-CA as a language tag. The fr and CA parts are referred to as subtags when described as parts of a tag. When described as members of an ISO list of languages or countries, fr and CA are referred to as codes.
(from http://www.w3.org/International/articles/language-tags/)
Some more links:
I'd like to read a good reason to choose another name.
Comment #24plach CreditAttribution: plach commented
do you mean 'tag' or 'language_tag' would be the column name in the node table, fields tables, url_alias, etc? Would this be clear to developers?
As I was saying above, IMO the language tag terminology should replace the language code terminology. For the sake of brevity I used
$tag everywhere, that's a mistake: I should have used
$language_tag, since that's not ambiguous and IMO fairly understandable even for non-i18n people.
That said, we might want to change all the 'language' columns in 'language_tag' columns for consistency, since they are identifiers (we used to have a 'nid' column column to reference nodes and not a 'node' one), but that might be overkill since a language tag is far more readable than a nid. If I had to choose I'd be with Jose and leave language reference column names alone.
Perhaps we might want to make an exception for the
{language} table and have a
tag column there, since there the scope would be unambiguous. This would allow us to have
$language->tag which would be shorter than what we have now.
Long story short: replace 'code' with 'tag' in #19.
I do see how the W3C standardized on this terminology, but have not seen it in implementations anywhere.
This is slightly misleading, but http://en.wikipedia.org/wiki/Locale says that Microsoft is standardizing on BCP47 for locale identifiers. POSIX platforms still go for the usual
[language[_territory][.codeset] form for now.
We can of course be the leading force here if people agree, but we should accept the education component involved then IMHO.
Hey, we would not be switching to klingon :) I think 'language tag' is more or less as much understandable as 'language code'.
Edit: Obviously if we switch to tags we have to properly support them, validating user input for custom languages and changing the language tag column length and this can be annoying.
Comment #25Jose Reyero CreditAttribution: Jose Reyero commented
While I don't mind that much the terminology I think the issue of locale vs language is worth discussing, so I've created this new thread #1218650: Separate language and locale. Proper languages for content translation.
Comment #26sun CreditAttribution: sun commented
Speaking of language and locale information on monolingual sites... or rather, using language/locale meta info for other purposes than t() string translation:
#1220964: Number field prefix/suffix get t()'ed through format_plural()
Comment #29catch CreditAttribution: catch commented
Apart from machine_name being Drupal jargon, is there a particular reason not to use that instead of $langcode/$language?
en, en-GB etc. should all be unique string identifiers, which is how machine_name works too in other places.
That would be inconsistent with other platforms, but seems very internally consistent within Drupal itself - sometimes we need to choose one or the other.
$langcode always seems like a natural abbreviation to me - like using $nid instead of $node_id, but I know we try to avoid in general and couldn't find evidence that anyone else uses it.
$tag - the main issue is confusion with tagging, but if it's part of a spec then that overrides the overloading (which is not a Drupal-specific issue at all).
I'd also probably be fine with $language_code as variable name and {language}.code as column name, but calling a db table 'code' seems a bit off.
Comment #30plach CreditAttribution: plach commented
I'm ok with #28, and I'm not holding my position about language tags at any cost, it just looks like the best choice to me if we have to address this subject cleanly. However if we just want to proceed and perhaps revisit this later with clearer minds, I'm totally ok with retaining the 'code' terminology proposed in #19:
$language->code (local object)
$language_suffix->code (global object)
No special preference about how the global ui language should be called, the only teo alternatives that come to my mind are:
$language_interface (which was in D7 core for a while)
$language_ui (which is shorter and perhaps more clear)
Comment #31plach CreditAttribution: plach commented
Crossposted with @catch:
$tag - the main issue is confusion with tagging, but if it's part of a spec then that overrides the overloading (which is not a Drupal-specific issue at all).
Please note that the correct way to adhere to the spec is using
$language_tag, which is longer but unambiguous.
Comment #32catch CreditAttribution: catch commented
OK so for me:
machine_name - unless there's a specific reason not to, seems imperfect but workable.
$language_tag - it is good to comply with specs, and seems OK.
$locale - not keen on this so much, other projects are using it but do they have a whole module call locale?
$language->code, not keen on having {language}.code, {language}.{language_code} is a bit verbose, $language->code itself seems fine. That's minor nitpicking.
Comment #32.0catch CreditAttribution: catch commented
Better summary
Comment #34sun CreditAttribution: sun commented
Everyone, please note the updated issue summary. There's one essential question in it, namely: Is there a difference between global $language and a loaded $language? Aside from that:
AFAICS, we need at least a two-phase process; stop-gap fix in order to make progress with the other issues, and a more far-reaching long-term fix (i.e., major API change, possibly requiring schema changes + lots of lots of lots of code to be rewritten).
Stop-gap fix proposal:
- $langcode for language identifier
- $language for global $language, as well as a loaded $language
- $language->language (== $langcode)
$node->language == $langcode
$language = language_load($langcode);
$language->language == $langcode
global $language_interface
Still ambiguous regarding global $language and $language object, but at least no far-reaching API change for now.
Long-term fix:
Regarding DX, retaining the current 'language' schema columns and object properties might be favorable. It's easy/trivial to understand, and also makes sense as an $object->language property/value. You don't expect a language object there. And if you call something a "language" in written/spoken language, then you normally mean a language identifier. In other words, this would make some sense and resolve a big part of the inconsistency already:
$langcode => $language
But obviously, this leads to the question of how to name a language object then. No ideas for that. Except for perhaps explicitly using $language_content and $language_interface everywhere (...which, might, clarify some confusion even...)
We should revisit the "locale" proposal though. Recent discussions changed my perspective. While "locale" indeed summarizes many language and territory specific factors, these locale rules seem to map 1:1 to language codes, as defined in _locale_get_predefined_list(). In case multiple choices for individual locale rules are possible for a certain language, then those will be configurable on the language object. Just like date formats are bound to $langcode already.
So meanwhile, I could as well imagine the following long-term fix to work:
$language = language_load($locale);
global $language
Comment #36sun CreditAttribution: sun commented
|Needs work
|» Needs review
Sure, the
global $language_interface adjustment in #35 would work for me, too.
What do others think about this? Given an agreement, we could start to compile a list of @todos that would have to happen based on the proposal (ideally in the issue summary). But I don't want to start thinking about technical implementation specifics before reaching an agreement.
Comment #37catch CreditAttribution: catch commented
Given so many projects use locale, I'd also be happy with:
$language = language_load($locale);
global $language_interface
Also the argument about locale and things like en-gb also make sense - not only spellings but date formats are different, however they're neither different languages nor dialects so what else do you call that?
Comment #37.0catch CreditAttribution: catch commented
Updated issue summary.
Comment #38wmostrey CreditAttribution: wmostrey commented
Isn't that simply locale? We've worked on this before in #310520: Introduce country-appropriate date handling and #318008: locale based handling and rendering for example.
Comment #39catch CreditAttribution: catch commented
Sorry that was a rhetorical question, that's why I think $locale is a decent choice.
The only problem with it is that 'locale' module doesn't actually deal with this stuff, but that's not a good reason to avoid using it here.
Comment #40fgm CreditAttribution: fgm commented
The global
$language is one place where we could reuse the
culture term since it has been avoided, and this is an fully loaded object with lots of locale/culture-related information, and this is not an unfamiliar terms for other uses cases beyond Drupal.
Also, there were several mentions of ISO639, but we need to take into account, should we want to use something like
$iso639 instead of
$langcode, that :
- the familiar "en", "fr" langcodes are only one of the facets of the standard, which also defines other codes, (and specifically 3-character ones)
- the language/locale to iso-639 mapping is not completely 1-to-1:
- several spanish languages are mapped to ast (iso-639-[23]) and have no iso-639-1 code
- some languages have more than one mapping, like armenian having both
hyefor iso-639-[23], but only
hyfor 2-letter iso-639-1
- all language without an official code are lumped together under
misin 639-3 and have no official 639-1 code
Comment #42sun CreditAttribution: sun commented
Briefly talked to @fgm in IRC in order to understand and clarify #40:
He thinks that Locale should denote an object having various properties to deal with specifics to a culture.
His proposal would thus be:
$locale = language_load($language);
global $culture
My personal thoughts and feedback on that:
We additionally have content language (in
$language_content), which is mainly about language, but might possibly also contain "culture" related locale information in the future. For example, content language applies to field values -- Input filters on text fields, as well as field formatters on number and currency fields require locale/culture information to format field values correctly. So while
$locale as an object would make some sense to me, the
$culture proposal does not.
Comment #43andypost CreditAttribution: andypost commented
Comment #45wmostrey CreditAttribution: wmostrey commented
Ok then I think we agree on what $language and $locale entail. I would propose this change though:
Instead of:
$node->locale // "en-gb"
$language = language_load($locale); // object containing all language information
$language->locale // "en-gb"
To have this:
$node->locale // "en-gb", could also be named ->lid
$locale = locale_load($node->locale); // object containing all locale information
$locale->language // "English" or "en"
And possibly:
$language = language_load($node->locale); // "English" or "en"
$locale would then contain variables like language, region, deciamel mark, date/time format, ...
The idea is that one specific locale will always contain the same values (so $locale->langue will always be the same), while one language can come from multiple locales (so $language->locale can be different whether the locale is en-gb, en-us or en-ca).
Comment #46sun CreditAttribution: sun commented
The idea is that one specific locale will always contain the same values (so $locale->langue will always be the same), while one language can come from multiple locales (so $language->locale can be different whether the locale is en-gb, en-us or en-ca).
By normalizing language from locale (i.e., mapping multiple locales to one language [without territory/culture]), we'd essentially remove a currently existing feature; namely, being able to translate content into "localized language".
Might not make too much sense for American English, British English, and Canadian English; but I can only guess it makes a huge difference for localized languages like Simplified Chinese and Traditional Chinese, as also discussed in #1218650-2: Separate language and locale. Proper languages for content translation..
OTOH, I can see the point of setting up two different locales, say, en-us and en-gb, but only one English (en) language. That would allow you to use proper localized formats for dates, currencies, etc. for each locale, while only having one language to translate content into.
In turn, you could have only two language switcher links, say, English (en) and German (de), which may decide on interface and content language, but then you might be able to additionally use URL or browser language negotiation to show the interface and content in English (en), but everything that can be localized in the appropriate locale (en-us or en-gb).
But regardless of that, you'd need a default/standard locale per language, so in the end, that entire functionality would merely lead to extending the language/locale object:
$language->language = 'en'; // Pure convenience, not used anywhere.
$language->locale = 'en-us'; // Default language/locale.
$language->optionalLocales = array('en-gb'); // Alternative locales.
Comment #47wmostrey CreditAttribution: wmostrey commented
I like the idea of a default locale per language, with optional locales attached. I also believe this is a solution for #1218650: Separate language and locale. Proper languages for content translation., I'll follow up there.
So my vote also goes to
$language = language_load($locale);
global $language_interface
Comment #49plach CreditAttribution: plach commented
|Needs review
|» Needs work
Honestly I don't like where this discussion is heading, IMHO if we take the direction outlined in the latest posts as the long-term fix, we are going to create further confusion wrt terminology and inconsistency with official specifications.
What really annoys me of the latest proposal is using the term
locale to identify a language:
$language = language_load($locale);
A locale is a totally different thing from a language, the fact that they may use a similiar identifier, just because both use a scheme involving geographic information, does not mean they can be used interchangeably.
Moreover locale and language identifiers don't always match, there are lots of attempts to classify them and language tags are only one of them, although apparently the most popular atm. Suffice to say the Posix systems use Locale identifiers that differ from language tags.
Apparently only Microsoft is using language tags (i.e. language identifers) to identify locales, which makes much more sense than the opposite.
This is the wikipedia definition of Locale (emphasis mine):
In computing, locale is a set of parameters that defines the user's language, country and any special variant preferences that the user wants to see in their user interface. Usually a locale identifier consists of at least a language identifier and a region identifier.
I cannot see this apply to nodes in any way: would that imply that a node has a country, a date format or a currency? Nodes, like any other content, have a language not a locale, we cannot make things this confusing to solve an ambiguity in our current terminology.
If we want to introduce locale support in core (and I would be totally fine with that), we should have a global
$locale object (or any context-provided equivalent) holding all the properties that a locale is supposed to provide, including language. Identifying locales through languages would make much more sense to me, since the language is perhaps the most characteristic aspect of a locale (and that's why probably their identifiers tend to be so similar).
This would lead to something like:
$locale = locale_load($language_tag); // or
$locale = locale_load($language_code); // and then
// ...
I'm not stressing on the language tag terminology anymore, although it's the currently recommended standard, because, as the wikipedia article above points out, language code is a more general terminology that include also language tags.
Another thing I'd like to outline is that locale pertains to user interface, hence in the scenario above I'd imagine the
$locale global to be initialized from interface language:
global $language_interface;
$locale = locale_load($language_interface->language_code);
About what @sun said in #42:
We additionally have content language (in $language_content), which is mainly about language, but might possibly also contain "culture" related locale information in the future. For example, content language applies to field values -- Input filters on text fields, as well as field formatters on number and currency fields require locale/culture information to format field values correctly.
This does not make any sense to me: content language should be used only to select which content has to be displayed, in the case of a currency field we should be using content language to determine the amount to display, while interface language should be used to choose the currency to be used (if not explictly negotiated).
About the need of sharing content among different languages, I'd like to quote what I was saying in the related issue:
I'd argue that since two languages albeit very similar might actually differ in some forms (I'm not taking into consideration the scenario in which different content has to be provided for different locales), this is a degnerated case of fall back: if I understand italian perfectly and I understand (british, american, whatever) english reasonably well, I might want to read content in english if not available in italian. With the same scenario in mind, an editor not wishing to provide a "british english" version of an "american english" content (for obvious reasons) might want both locales to access it: an american user would see it "natively", while an english user would see it because some smart fallback rule decided that was the right content to display.
British english and American english are different languages if we are using a language identifer that involves geographic areas. If the scenario above is the exception, IMO it should be solved with the fallback approach or some advanced content language detection method, if it's the rule the language identifier is simply too granular.
Alternatively this could be solved by having the ability to enable different languages for each language type, we then might be able to say that our interface languages are [en-US, en-GB, es-ES, es-AR] and our content languages are [en, es].
This makes me think that if we introduce locale support we might simply want to drop the interface language and merge it into the $locale object.
To sum up, IMO the way to go should be:
$node->language_tag // or language_code
$language = language_load($language_tag);
global $language_interface
we might also have:
since in many places now we require a language object and not a language code.
Comment #50plach CreditAttribution: plach commented
After reading #49 again, also
$locale = locale_load($language_tag); // or
$locale = locale_load($language_code); // and then
does not make much sense to me, since language identifiers might not hold a country identifier. If we have locale support we must use separate locale identifers. However those could be determined through the same information used to negotiate language.
Comment #51gbentley CreditAttribution: gbentley commented
Whilst discussing semantics, remember what many developers want: the ability to create multi-lingual sites with specific content for particular country/language combos. I can do this simply in eZ Publish because they chose a solution, and it works. I'd like to do the same in Drupal.
Comment #53plach CreditAttribution: plach commented
@Gábor Hojtsy:
in short, you are saying that most other system listed in #18 (ezPublish, Wordpress, CakePHP, Symphony, etc) do it wrong entirely by calling their language codes locales?
I'm not an authorirty in this matter but from the documentation I read this is exactly my position. It may be silly or wrong, but I did not read a single line to prove that yet.
I think we have a lot more pressing problems in terms of content translation and especially configuration translation, that should be our larger focus
I think we agreed to have a short-term a fix to allow us to go on and long-term fix to solve things in a consistent way. IMHO #48 does not fly as a long term fix, and I cannot see how it can be a short term fix, so that's what I'm discussing.
However I'm not so interested in this issue to make everyone waste their time on it, I just meant to post my feedback since I'm listed in the maintainers list for this very subject. I'm sorry I cannot agree, but I don't think this should block development if everybody else do.
A stop gap fix could be:
$language = language_load($langcode);
global $language_interface
Any other clean up could wait for a more defined context.
Comment #54fago CreditAttribution: fago commented
$uid => {language identifier}
$user => {global language}
$account => {a language}
I don't think this is an example we should aim for. Imo the user example is not at all sound and consistent either. The entity type is 'user' but instances are $account, still there is a certain special instance we call $user (but is not really a regular user entity..) .. wtf?
We should not call the variable different just because it is the global one. I know why we do that, but wouldn't the need for "global $foo" go away anyway with the context initiative? So, imo every language object should be just called $language.
For now we could just go and use $GLOBAL['language'] as we have it already, but invent a simple getter function to avoid variable naming issues, e.g.
$language = language_global();. That way overwriting $language would not overwrite $GLOBAL['language'] + we have a name less to care for + 1 inconsistency less.
Then, for $language I think we should just follow the pattern we use elsewhere. Imho we have two patterns:
1. Invent abbreviations for properties (nid, uid, ..)
-> The same way we could just invent langcode (as we partially have already done) and use
$language->langcode and
$langcode - just as we use $node->nid and $nid.
2. Use a general property name ('name') + prefix it if used stand-alone
We have some properties named generally, like vocabulary 'machine_name', or term 'name'. Once we are passing them as separate variable we usually prefix the "container-name", like $vocabulary_machine_name or $term_name.
-> In case languages I think the general property name should be probably 'code' not 'name. So what about using
$language->code and
$language_code if used standalone.
Personally, I'd not mind if we have language codes that look like locale identifier. If they are really just used as language identifiers, we should call it that way. If we want to support more localization options (decimal separation, ..?), we might want to call the whole object $locale though (
$locale->code and
$locale_code?). Mixing $language and $locale doesn't make much sense to me.
Comment #56catch CreditAttribution: catch commented
Using GLOBALS to avoid the collision is a good suggestion, much prefer that to declaring global $foo and we already use that some places on core, also that the global should go away with context object.
Comment #57plach CreditAttribution: plach commented
+1 for #54 (especially point 2)
Comment #59plach CreditAttribution: plach commented
Totally agreed.
Let's recap pros and cons of what has been proposed in #54 corrected with #58:
- Language identifier
- We choose the 'code' terminology, so:
$language->code $language_code $language->code == $language_code $node->language_code == $language->code
Pros: it's easy to read, it's not too long and close to what we have now.
Cons: it introduces a difference between the object field and the variable name, although globally they look very similar. @fago points out that we have similar cases in core already. Node syntax is not very friendly but neither
$node->nidis after all. Personally I'd be ok even with:
$node->language == $language->code // more readable but less consistent and ambiguous $node->language->code == $language->code // more consistent but more verbose
- Local object
We keep the
Pros: This is perfect, exactly what we want. Everyone is happy, angels sing and so on.
Cons: no one known.
- Global object
Short term fix: rename it
$language_interface. Long term fix: get it from the request context.
Pros: it's consistent with the other language globals.
Cons: It's ver long (who really cares?).
Pros and cons of what has been proposed in #48:
- Language identifier
- We choose the 'locale' terminology, so:
$language->locale $locale $language->locale == $locale $node->locale == $language->locale
Pros: it's easy to read, it's short and very consistent.
Cons: it might clash with a (local or global)
$localeobject, if we end up introducing it; it's misleading and error prone: locale identifiers are required to have a region identifer (at least by reading the wikipedia definition), where language identifers are not.
The rest is the same.
Comment #60plach CreditAttribution: plach commented
It is all about enabling us to use $language as a name in the meantime, so we don't need to wait for them. Looks like a simple global rename is the quickest path to there, no?
should be enough to unblock the language CRUD issue. The language identifier issue is minor compared to the global one.
Comment #61fago CreditAttribution: fago commented
>exactly on the assumption that globals will be replaced by context object values and will work much different, my view is that we should get rid of $language as a reserved word for now, rename it to something that makes sense for the global scope and then leave its integration and rework in contexts to the context initiative flow.
Yes, but the point is we do not need to discuss and come up with another name for the global as it's about to go away anyway. Also having another name for it because the object stems from $GLOBALS is just silly and something inconsistent new developers need to get used first.
>I have not seen $GLOBAL['user'] or $user = user_get_global(); as a pattern in core,...
Me neither. But we could use it until $context arrives, so we can save the whole discussion about the alternative name of $GLOBALS['language']. Search/replace "global $language" with "$language = $GLOBALS['language'];", demonize the use of "global $language" and $language got freed. I'd personally favour a helper like
$language = language_get_global()" or maybe
language_current() though.
>I still think having $language->language == $langcode looks crap..
I haven't suggested that. The variant 1 I outlined was using $language->langcode and $langcode, see #54.
Comment #62catch CreditAttribution: catch commented
catch@catch-laptop:~/www/8$ grep -r "GLOBALS\['user" *
includes/common.inc: $GLOBALS['user'] = drupal_anonymous_user();
includes/common.inc: $GLOBALS['user'] = $original_user;
includes/form.inc: if ($GLOBALS['user']->uid) {
modules/tracker/tracker.module: return $account->uid && ($GLOBALS['user']->uid == $account->uid) && user_access('access content');
modules/user/user.tokens.inc: $account = user_load($GLOBALS['user']->uid);
modules/user/user.test: $global_account = user_load($GLOBALS['user']->uid);
modules/user/user.module: if ($account->uid == $GLOBALS['user']->uid) {
modules/user/user.module: if ($GLOBALS['user']->uid) {
modules/user/user.module: return !$GLOBALS['user']->uid || !empty($GLOBALS['menu_admin']);
modules/user/user.module: return (bool) $GLOBALS['user']->uid;
modules/user/user.module: if ($GLOBALS['user']->uid == $uid || user_access('administer users')) {
modules/user/user.module: return (($GLOBALS['user']->uid == $account->uid) || user_access('administer users')) && $account->uid > 0;
modules/user/user.module: return ((($GLOBALS['user']->uid == $account->uid) && user_access('cancel account')) || user_access('administer users')) && $account->uid > 0;
modules/user/user.module: drupal_goto('user/' . $GLOBALS['user']->uid . '/edit');
modules/user/user.module: $uid = $GLOBALS['user']->uid;
modules/user/user.module: return empty($arg) || $arg == '%' ? $GLOBALS['user']->uid : $arg;
modules/user/user.module: $uid = $GLOBALS['user']->uid;
modules/node/node.admin.inc: if (user_access('view own unpublished content') && $own_unpublished = db_query('SELECT nid FROM {node} WHERE uid = :uid AND status = :status', array(':uid' => $GLOBALS['user']->uid, ':status' => 0))->fetchCol()) {
modules/node/node.module: if (user_access('view own unpublished content') && $own_unpublished = db_query('SELECT nid FROM {node} WHERE uid = :uid AND status = :status', array(':uid' => $GLOBALS['user']->uid, ':status' => NODE_NOT_PUBLISHED))->fetchCol()) {
modules/node/node.module: $account = $GLOBALS['user'];
modules/profile/profile.module: if (user_access('administer users') || $GLOBALS['user']->uid == $account->uid) {
catch@catch-laptop:~/www/8$ grep -r "GLOBALS\['lang" *
includes/common.inc.orig: $langcode = $GLOBALS['language_content']->language;
includes/theme.inc: $variables['language'] = $GLOBALS['language'];
includes/theme.inc: $variables['language']->dir = $GLOBALS['language']->direction ? 'rtl' : 'ltr';
includes/theme.inc: $variables['language'] = $GLOBALS['language'];
includes/theme.inc: $variables['language']->dir = $GLOBALS['language']->direction ? 'rtl' : 'ltr';
includes/theme.inc: $language = isset($GLOBALS['language']) ? $GLOBALS['language'] : language_default();
includes/common.inc: $langcode = $GLOBALS['language_content']->language;
includes/menu.inc: $cid = 'links:' . $menu_name . ':all:' . $mlid . ':' . $GLOBALS['language']->language . ':' . (int) $max_depth;
includes/menu.inc: $cid = 'links:' . $menu_name . ':page:' . $item['href'] . ':' . $GLOBALS['language']->language . ':' . (int) $item['access'] . ':' . (int) $max_depth;
includes/menu.inc: $tree_cid = 'links:' . $menu_name . ':tree-data:' . $GLOBALS['language']->language . ':' . hash('sha256', serialize($parameters));
includes/menu.inc.orig: $cid = 'links:' . $menu_name . ':all:' . $mlid . ':' . $GLOBALS['language']->language . ':' . (int) $max_depth;
includes/menu.inc.orig: $cid = 'links:' . $menu_name . ':page:' . $item['href'] . ':' . $GLOBALS['language']->language . ':' . (int) $item['access'] . ':' . (int) $max_depth;
includes/menu.inc.orig: $tree_cid = 'links:' . $menu_name . ':tree-data:' . $GLOBALS['language']->language . ':' . hash('sha256', serialize($parameters));
modules/comment/comment.module: $langcode = $GLOBALS['language_content']->language;
modules/comment/comment.module: $langcode = $GLOBALS['language_content']->language;
modules/user/user.module: $langcode = $GLOBALS['language_content']->language;
modules/user/user.module: $langcode = $GLOBALS['language_content']->language;
modules/taxonomy/taxonomy.module.orig: $langcode = $GLOBALS['language_content']->language;
modules/taxonomy/taxonomy.module: $langcode = $GLOBALS['language_content']->language;
modules/node/node.module: $cid = 'node_types:' . $GLOBALS['language']->language;
modules/node/node.module: $langcode = $GLOBALS['language_content']->language;
modules/node/node.module: $langcode = $GLOBALS['language_content']->language;
Comment #64sun CreditAttribution: sun commented
Realized that #34 didn't contain a code example mimicking the short-term proposal. Updated that with:
$node->language == $langcode
$language = language_load($langcode);
$language->language == $langcode
global $language_interface
So regarding the stop-gap fix, we still seem to be in line; @plach stated the identical code in #53. It allows us to move forward with all of the currently postponed issues for now.
Regarding the long-term proposal, it looks like our major pain point is the language identifier name.
- The name of the language identifier has a direct impact on the names of objects, globals, properties, and schema columns, since there is already a name clash between language identifier and aforementioned other things, and any change to the language identifier name will lead to name clashes, too.
- We therefore would have to figure out first what the proper name for the language identifier should be. This cannot be discussed and decided isolated on its own, since names like "locale" potentially imply a whole different meaning, preventing us from actually implementing and using that other meaning in the future (without renaming everything once again).
I'll try to capture this as well as #59 in a cleaner way in the issue summary.
Comment #67fago CreditAttribution: fago commented
I don't think it makes sense to rename it just for the cause of avoid the "name-clash" when using "global $language", which I thought was the primary reason for re-naming. But given we already have three global languages it probably helps cleaning that up anyway. So I'm fine that too.
ad #64:
I think it's fine to have $node->language containing just the language identifier, compared to $comment->pid,cid,uid,nid,.. it's much more descriptive. I could see us going with that way with other entity properties too, e.g. $comment->node containing a nid + an easy way to access loaded objects.
Still, we should avoid $language->language though as it makes it totally unclear whether a $language parameter is the object or the id... The $language->code and $language_code variant makes that clear.
Comment #68plach CreditAttribution: plach commented
Still, we should avoid $language->language though as it makes it totally unclear whether a $language parameter is the object or the id...
I think everybody here agree this is not ideal, are you talking about the stop-gap fix or the long-term fix? Because fixing it sounds very long-termish ;)
Comment #69sun CreditAttribution: sun commented
Still, we should avoid $language->language though as it makes it totally unclear whether a $language parameter is the object or the id...
Sorry for leaving that out, but the stop-gap fix proposal would potentially also involve to possibly fix all instances of
$language throughout Drupal core, which actually contain a
$langcode (and not a language object). I'm mainly thinking of hook and callback function signatures here.
And now that you've read that paragraph, you might wonder about the extreme subjunctive wording. While I'd personally highly welcome if someone would run over Drupal core and change all $language to $langcode where no actual $language is passed, the stop-gap fix proposal primarily intends to resolve the variable naming problem for code that is being touched in the list of related and currently blocked/postponed issues.
In other words: An agreement on the stop-gap fix proposal implies a new rule for all upcoming core patches (from now on) to use $langcode and $language appropriately in code that is being changed. Violation of this rule means "needs work" (with a pointer to this issue). However, it does not necessarily mean we have to make all of core consistent immediately.
Comment #70fago CreditAttribution: fago commented
I think everybody here agree this is not ideal, are you talking about the stop-gap fix or the long-term fix? Because fixing it sounds very long-termish ;)
I think that's something we need to address in the long-term, as changing it too often probably just creates unnecessary headaches.
#69 sounds like a good way to proceed.
Comment #71plach CreditAttribution: plach commented
I'm ok with #69 too.
Comment #72wmostrey CreditAttribution: wmostrey commented
#69 seems like a very good plan, agreed.
Comment #79plach CreditAttribution: plach commented
It seems our double-fix strategy is not performing that good, is it under discussion again? Gabor, are you suggesting to find a unique definitive (OMG:) fix?
In this light I have a proposal that at first might sound silly, but perhaps could solve many of the issues reported in #75 and #77:
$node->language == $language
$language_data = language_data_load($language); // or $language_object or $language_properties or anything you like better :)
$language_data->language == $language
global $language_interface // this might be a little inconsistent, but it should be only a temporary fix
Let's RRRUMBLE again!
Comment #80plach CreditAttribution: plach commented
Another one, not sure it'll work :)
class Language {
protected $code;
protected $native;
// ...
function __construct($language_code) {
$this->code = $language_code;
// ...
function __toString() {
return $this->code;
$language = new Language($language_code)
$node->language == $language
Comment #82plach CreditAttribution: plach commented
F**k, $data is already plural, it's from latin (singular datum, plural data) :(
Aside from this detail, do you like the idea of renaming local objects? If so we can try to find another name.
Comment #84plach CreditAttribution: plach commented
We derive names from the object name though, $language_* globals are derived and will be misleading if not renamed to use the object name then (such as $language_data_content instead of $language_content if it would be a good name :). This probably gives a perspective as to what environment should the object name stand.
Yes, this is what I meant with inconsistency in #79, but can't we assume that those globals will go away with the WSSCI? I can imagine the following scenario:
$language_data = context()->get(LANGUAGE_TYPE_INTERFACE);
What about
Comment #86plach CreditAttribution: plach commented
Perhaps this needs a feedback from Dries? I feel rather stuck :(
Comment #87webchick CreditAttribution: webchick commented
Something that would help on my side is if the issue summary could be edited with an example of what each of these things would output through echo/var_dump().
Comment #87.0webchick CreditAttribution: webchick commented
Updated issue summary.
Comment #89plach CreditAttribution: plach commented
My favorites in each column are $lcode, $ltag, $locale and $lid respectively, depending on which compromise do we make (based on the other Drupalisms $nid, $uid, $rid, $tid, etc, which you all need to learn working with Drupal, so $lX would not be a stretch at all).
About $locale I already said what I think, about $lx we'd have:
function field_attach_view($entity_type, $entity, $view_mode, $lcode = NULL) // or
function field_attach_view($entity_type, $entity, $view_mode, $ltag = NULL) // or
function field_attach_view($entity_type, $entity, $view_mode, $lid = NULL)
// and
$node->lcode == $lcode
$node->ltag == $ltag
$node->lid == $lid
I can already hear @chx screaming ;)
I'm afraid I'm still (very personally) leaning towards longer but more readable schemes such as:
$language->code == $language_code
$node->language_code == $language_code
function field_attach_view($entity_type, $entity, $view_mode, $language_code = NULL)
for the record tag is still my favorite terminology but this discussion is exhausting me, at this point I'll gladly accept any choice with joy (except for $locale ones :).
Comment #91webchick CreditAttribution: webchick commented
(Note: I haven't read this full discussion, just the issue summary and the #85. This is "by design" because I'm trying hard not to be influenced.)
As a general Drupalist, and not a Drupal language API expert, this is what makes the most sense to me.
$language: This is always the full language object, basically a SELECT * FROM language.
$language->lid: The primary key of the language table ('en' or 'de')
$node->lid: The language assigned to this node ('en')
$user->lid: The language assigned to this user ('de')
(I realize this would mean changing the intuitively-named 'language' column in the user/node tables to the Drupalism-named 'lid' column, but again the key is consistency.)
Xid is what we (almost) always use to refer to a table's primary key, or a foreign key to another table. user.uid, node.nid, node_revision.nid. This same pattern is used pretty much everywhere. I think above there were concerns that Xid is usually autoincrement, numeric primary key, but this isn't always the case. For example, the cache tables use 'cid' and this is a string like 'image_styles'.
$llid, $ltype is not a pattern used anywhere. Neither is $langauge_foo, $language_bar, $language_the_other_thing. We do $node->nid, $node->name, etc. when we want to refer to specific properties.
So yes, I'd prefer we stick with well-established Drupalisms here, rather than trying to introduce a new pattern which might arguably be more intuitive for newcomers to Drupal, but would be non-standard to everything else and would cause newbies to run afoul the first time they encoutered nodes, users, comments, taxonomy vocabularies, or basically anything else in Drupal. (Which, let's face it, they're far more likely to encounter first and have expectations set by than the inverse.)
Comment #93sun CreditAttribution: sun commented
Reading @webchick's comment and double-checking with the table in #85, I'm
-1 on "lid": Too many chances for name clashes with other "lids" in modules (e.g., Length ID, Loop ID, Large ID, whatever), and not descriptive enough for third-party function signatures (e.g.,
hook_node_view($node, $view_mode, $lid) -- WTF??).
+1 on "langid": In this entire discussion, we actually used the term "language identifier" in order to be able to communicate with each other in the first place. ;) So a $langid directly maps to "language identifier", doesn't come with code/tag/WTF, and is also crystal clear in database schemas (
{node}.langid) as well as on objects (
$node->langid). For some reason, the table in #85 notes that IDs would always be integers, but that is not really the case, or at least it's an extremely far stretch of trying to project a "rule" to current $*id variables, which also doesn't hold water if you consider the real-world term and usage of "ID" (e.g., social security numbers, passport numbers, UUIDs (!), etc).
Comment #95sun CreditAttribution: sun commented
why is $uid, $nid or $tid or $mlid not a WTF?
They are less of a WTF, because they are the IDs of the object at hand. $node » $nid, $term » $tid, $user » $uid, etc.
A $lid is out of context in a $node context. It could be the node's "last-revision-author-id" or whatever other thing you can think of and which you can abbreviate with "lid".
In this sense, $lid might clash with existing ids in contrib. With that thinking we'll never be able to introduce ids in the same pattern that most core objects use with this. There never can be an $xid, $zid or $wid or $kid in core for any new concept with fear...
The situation is different, since the context is different. We can certainly introduce new objects in core that use $lid, $xid, $zid, or $kid variables and keys within their scope and context, and there is going to be zero impact on any other module.
But as soon as we pass on something to other functions, we use a clear name. That's why we have $entity_type, $entity_id, $entity, etc and not $type, $id, ...
Very similar to language identifiers are text formats, which are also scattered throughout core and contrib, and across objects and table schemata. We also don't use
$fid there, and neither do we store
$field[0]['value'] with
A Drupal using $fid and $lid (for stuff like text fields even within the same context, yay!) would be an absolute horror scenario in my mind.
Comment #97webchick CreditAttribution: webchick commented
I would personally handle this by changing
hook_node_view($node, $view_mode, $lid)
hook_node_view($node, $view_mode, $language)
and just pass the entire $language object in for context. Ambiguity solved.
Comment #98catch CreditAttribution: catch commented
If a node has a language and you load the node, unless we munge it the column name is going to be $node->langcode or whatever the string is. For function arguments and the current global I think we're assuming that all gets replaced by context object.
Comment #100fago CreditAttribution: fago commented
-1 on lid too (see the linked issue for reasons).
I agree with Gabor that we should aim for consistency. Thus, let's rething the naming pattern once, then apply it. As this isn't only about languages I've opened #1233394: [Policy, no patch] Agree on a property naming pattern for that. Please comment.
Comment #102plach CreditAttribution: plach commented
I was thinking about posting something like #100 too, but then realized that it might bring detriment to the D8MI: there is no warranty that #100 will be accomplished in an useful timeframe, instead if we agree on a coherent pattern at least in the language scope, it should be easy to conform to any new approved standard coming out of #100 later. This would let us proceed with the other tasks (step > 0), leaving the discussion open for better and more consistent object identifers and property names.
So from me +1 to any proposed scheme that does not involve 'locale'.
Comment #104fago CreditAttribution: fago commented
Sry, my intention was not to hold anything up. However, I think this is something that needs to be discussed, and as outlined in #103, the sooner the better.
So what about giving the discussion a certain period of time (a week?) and then move on - even if there we were not able to reach consensus. Then someone has to make decisions to move on, and I think this is why it's good to have leaders or initiative owners..
Comment #106plach CreditAttribution: plach commented
Probably I did not express myself correclty: what I meant is that we should find a (possibily) definitive fix for language identifiers. If from #100 a different pattern emerges, massive changes through out Drupal core will be performed anyway, but at least having standardized on a consistent pattern in the language scope should help the global consistency issue to be accomplished.
That said, @fago's proposal of fixing a deadline after which going on anyway might make sense to avoid doubling the efforts.
Comment #109IceCreamYou2 CreditAttribution: IceCreamYou2 commented
I just read this entire issue, although I admit skimming the last 50 or so posts. For reference, I try to avoid anything language-related, and only deal with it when it's relevant for a module I'm writing -- and currently I find language support perennially confusing. So here's what I would do:
global $page_language; // The language the current page was requested in. $language_interface sounds like a default language regardless of user settings.
$language = language_load(); // $language is a full language object
For langcodes:
- "Locale" means "A place where something happens or is set, or that has events associated with it." It has nothing to do with languages. I don't care what other systems do. "Locale" is also the name of a module, and it feels like something named "locale" would be an object associated with the locale module.
- "Tags" is confusing. Even if you use "language_tag" everywhere (including in the {languages} DB column and $language objects) it still feels like you are "tagging" languages (and you could, with terms like "Western," "Latin," "LTR," etc.). Additionally note that what I'm calling langcodes here is not a standard; they're not langcodes because they use underscores, so it's just a convention that doesn't have a name (albeit a common convention).
- "Language" is obviously confusing.
- "language_id" kind of makes sense, but everything else with "id" in Drupal is a number, and we don't use the "[string]_id" pattern very often.
- "machine_name" is Drupal-y and obvious what it means. I like it. The only problem is it doesn't work on objects -- you can't write $node->machine_name. We should be consistent everywhere.
- "langcode" is also obvious. Even the current DB schema describes {language}.language as "Language code." We should always use "langcode" and never just "code." In my (admittedly limited) experience with languages I have never heard this called anything other than a language code. Also note: 824 results for "language code," 81 results for "language tag," 833 results for "langcode" (and "locale" is obviously not comparable). The one argument AFAICT against "langcode" is that coding standards usually dislike abbreviations. However, we already violate this all over the place in about a bazillion ways. To me "langcode" is most analogous to "nid"/"uid" which are also abbreviations.
Additionally, according to Wikipedia:
- "In computing, locale is a set of parameters that defines the user's language, country and any special variant preferences that the user wants to see in their user interface. Usually a locale identifier consists of at least a language identifier and a region identifier." (Emphasis mine. Although to be fair, that page confuses the concept of locale a bit too.)
- "A language code is a code that assigns letters and/or numbers as identifiers or classifiers for languages. These codes may be used to organize library collections or presentations of data, to choose the correct localizations and translations in computing, and as a shorthand designation for longer forms of language-name." There are a bunch of examples of language code standards on that page (Drupal doesn't use any of the standards there) including the IETF Language Tag spec.
- The Wikipedia pages for language codes like en-GB often explain it as a "language code."
All that said, I don't want to hold up actual work. Code is golden. If we standardize on something, it will be easier to change it later (though the chances we actually do are probably pretty low). So, if the bikeshed is over, forget I said anything and just get on with it. :-)
Comment #111IceCreamYou2 CreditAttribution: IceCreamYou2 commented
Ooh, thanks Gábor.
Re 1), my interpretation of IETF is that language tags use hyphens, and Drupal uses underscores, e.g. the standard is en-US and Drupal uses en_US. Same pattern, but that makes it different in my mind.
Re 2), thanks for clarifying. I like that approach. Would have saved me a whole lot of time if #1233394: [Policy, no patch] Agree on a property naming pattern was referenced in the issue summary. :-)
Comment #113IceCreamYou2 CreditAttribution: IceCreamYou2 commented
#8, #18, #19... I feel like somewhere in this thread someone mentioned something about it but I can't find it now and I may have read too much into it.
Comment #116plach CreditAttribution: plach commented
Works for me, although it's not my preferred solution among the ones presented here. I guess this might be revisited if the general issue gets somewhere. As said above, having a fixed schema to rely on will ease the task in this case.
Comment #117.0(not verified) CreditAttribution: commented
Make sure PHP code wrapping is ok.


text: I have had this hedge trimmer attachment now for almost 4 years. Never had any problems except for some of housing screws falling out. No big deal. Was using it last Saturday and noticed some smoke coming from the housing and it got a little worse. I finished the job and noticed that all four housing screws were gone. Bought four new screws, added some red lock tight and installed. Added grease, now it doesn't work when all screws are tight. If I loosen the screws about 2 rounds each, it will work but the grease comes out and the screws will fall out again. What is wrong with it? Any suggestions. Paid $290 for it. I'm a little afraid to take it apart. I have a parts diagram. It's model 99944200590.


text:
- 2304 CUDA Cores
- 3GB 384-Bit GDDR5
- PCI Express 3.0
Some manufacturers place restrictions on how details of their products may be communicated.
blah 07/20/2014
This review is from: MSI Gaming N780 TF 3GD5/OC G-SYNC Support GeForce GTX 780 3GB 384-Bit GDDR5 PCI Express 3.0 SLI Support Video Card
Heat pipes go over power plugs making removal difficult. Temps quite a bit higher then benchmarking sites quote.
Doesn't play nice with my soundblaster z, refusing to post unless I move it to slot farthest away from card.
Blue screens with watchdogs, the game it came with.
Other Thoughts:
I just got an email yesterday that they haven't received my mail in rebate several days after I could remail and get the rebate.
All in all not very impressed.
Manufacturer Response:
Dear Valued Customer,
We apologize for the issues that you are having with this product.
If you have not go through troubleshooting yet, then feel free to contact our tech support team for assistance at 626.271.1004 from M to F, 6am to 6pm Pacific Time.
If you have rebate issue you can email us at email@example.com
1. Full name (first, and last)
2. Telephone #
3. Physical address
4. Email address
5. Serial number (located in the battery compartment and begins with S/N)
6. Proof of purchase (screenshot/photo, or PDF is fine)
please include the following information when you email;
Best Regards,
MSI Review Team | email@example.com
1 people found this review helpful. Did you? Yes / No Thanks for the valuable feedback you provided!


text:
Anti-Tumor Effects of Atractylenolide-I on Human Ovarian Cancer Cells
Fangyi Long, Ting Wang, Ping Jia, Huafei Wang, Yi Qing, Tingting Xiong, Mengjie He, Xiaoli Wang
(Department of Pharmacy, Sichuan Provincial Hospital for Women and Children, Chengdu, Sichuan, China (mainland))
Med Sci Monit 2017; 23:571-579
Published: 2017-01-31
The aim of this study was to investigate the effects of Atractylenolide-I (AT-I), a naturally occurring sesquiterpene lactone isolated from Atractylodes macrocephala Koidz, on human ovarian cancer cells.
MATERIAL AND METHODS: The viability and anchorage-independent growth of ovarian cancer cells were evaluated using MTT and colony formation assay, respectively. Cell cycle and apoptosis were detected with flow cytometry analysis. The level of cyclin B1 and CDK1 was measured using qPCR and ELISA analysis. The expression of Bax, cleaved caspase-9, cleaved caspase-3, cytochrome c, AIF, and Bcl-2, and phosphorylation level of PI3K, AKT, and mTOR were determined with Western blot analysis.
RESULTS: AT-I decreased the cell viability and suppressed anchorage-independent growth of A2780 cells. Cell cycle was arrested in G2/M phase transition by AT-I treatment, which was related to decreased expression of cyclin B1 and CDK1 in a dose-dependent manner. In addition, the treatment induced apoptosis, as shown by up-regulation of Bax, cleaved caspase-9, cleaved caspase-3, and cytosolic release of cytochrome c and AIF, and down-regulation of Bcl-2, in a dose-dependent manner. Then, the effects of AT-I on PI3K/Akt/mTOR pathways were examined to further investigate the underlying anti-cancer mechanism of AT-I, and the results showed that treatment with AT-I significantly decreased the phosphorylation level of PI3K, Akt, and mTOR.
CONCLUSIONS: This study demonstrated that AT-I induced cell cycle arrest and apoptosis through inhibition of PI3K/Akt/mTOR pathway in ovarian cancer cells. These results suggest that AT-I might be a potential therapeutic agent in the treatment of ovarian cancer.
Keywords: Apoptosis Inducing Factor, cell cycle checkpoints, Ovarian Neoplasms


text:
Surfboard smashes through a car window causing a traffic mess
A surfboard punctured the windshield of a car on the H-1 freeway yesterday morning, causing one eastbound lane to be closed for almost 20 minutes. Traffic was stopped on the eastbound left lane on the H-1 near the Punaho Street Overpass just before 11am. It wasn't immediately clear where the board came from. There were no injuries to the occupants.


text:
Delete a Places To Swim Listing
Current Entry:
- Kailua - KONA Kona Aquatics
- Hawaii LMSC
- Kona Community Aquatics Center (County Pool)
- 75-5530 Kuakini Highway Kailua, HI 96740
- Lap Swim / Workout Times: M & F 6:15 - 7:15 am, W 6 - 7:00 pm, Technique Class- Wed. 6:15amed.
- Contacts: Steve Borowski, 808-334-0083, email@example.com
- Miscellaneous Info: See Coach Steve regarding great ocean swims
- Record Last Updated: 10/4/11
Confirm Deletion:
Please provide your name and E-Mail address so that we know who to contact if there are any questions. Note that the your database deletion request will be reviewed by the database administrator for verification and future update - the listing will not be immediately deleted.


text:
Reviewed By Lyle B (GRAND RAPIDS, MI) Reviewed for a 1999 Ford F-150 —10/31/2014 6:10 PM
Replaced the worn out OEM shocks on my 1999 F150 4x4 with these. Love the ride and control they give me after years of riding on worn out shocks. I would definitively buy these again and recommend them to a friend.


text:
Become a part of the Eagle Nation and join the Association that helps support
Georgia Southern University!
The Georgia Southern University Alumni Association offers programs, services and interactive tools to serve each of our more than 75,000 Georgia Southern alumni around the world. You do not need to have attended Georgia Southern to be an active member; many members are spouses, family members or friends of the University.
Active membership in your Alumni Association makes Georgia Southern stronger! Membership dues help provide scholarships for some of the best and brightest students; enhances the Alumni Association's outstanding programs, events and services; and keeps you informed about the University through publications like the Georgia Southern Magazine and our electronic newsletter. Even better, your dues may be tax deductible (consult your tax advisor.)
To join the Alumni Association Click Here.


text:
Drug Abuse Tools, Apps, & Videos
Videos and interactive tools and apps can help you assess the impact of drug use on your life, reduce your use, and regain control.
- Alcohol and Drugs - Assessment & Workshop
- Assessment and feedback from afterdeployment.org can help you decide how drugs may be impacting your life and how you can reduce your use.
- Prescription Drug Abuse videos
- A PSA campaign—"More isn't Better"—educates Warfighters and their families about the negative effects of misusing prescription drugs.
- Bath Salts: It's not a fad...It's a nightmare
- U.S. Navy Medicine has created a video on bath salts, a potentially dangerous designer drug.
- Spice: It's Not Worth It
- U.S. Navy Medicine has created a video that highlights the dangers of the designer drug Spice.
- National Institute on Drug Abuse videos
- The National Institute on Drug Abuse (NIDA) has created videos on various topics about drug abuse.


text:
Woman From Houston Texas Has A Three-Story Closet [VIDEO]
Subscribe to Hot 107.9 on
This is a woman's dream closet, standing three stories high. There is no way you can't find something to wear!
As much as I want that statement to be true, most women would still say they can't find anything to wear…LOL!!
Theresa Roemer probably doesn't have that problem when she and her friend designer Thom Anderson from Houston, created a three-story, 3,000 square-foot boutique-like space to house her huge collection of designer labels. It even has a champagne bar on the 2nd floor. Mrs. Roemer says:
"Yes, it's full of amazing things, but this closet was built and intended for fundraising."
Mrs. Roemer has raised millions for places like Texas Children's Hospital and Child Legacy International.
She says her new closet will continue to get the women she hosts, to open their hearts and checkbooks for the causes she supports.
Just in case you were wondering, she calls it her "She-Cave." I kind of like the tone of that.
Now check out the video and take a tour.


text:
Tyler Toffoli scored his first NHL goal in only his second game with the Kings and his name began trending on Twitter in his native Canada almost instantly.
Kings fans celebrated the moment by giving the rookie forward a rousing standing ovation.
"It was incredible," Toffoli said. "I didn't expect that. I had goosebumps.
"It was a great feeling."
You only score your first goal once, and the 20-year-old Toffoli did it by blasting a loose puck past Phoenix Coyotes goaltender Mike Smith for a power-play strike midway through the second period of Monday's 4-0 victory at Staples Center.
Toffoli celebrated with a scream and a couple of fist pumps. It was a big goal for him and for the Kings, who also got markers from rookie defenseman Jake Muzzin and veteran forwards Anze Kopitar and Jeff Carter.
Jonathan Quick made 27 saves for his 25th career shutout.
"The last game I had a couple of good chances, so that's why I really wanted to put it in," Toffoli said, referring to his NHL debut in Saturday's victory over the San Jose Sharks. "I got a good bounce and (Jeff) Carter made a good play to me and I just shot it."
The puck soon will be on its way to Toffoli's parents, who also have the souvenirs of his first goals in the minor-league American Hockey League and the junior-level Ontario Hockey League. In fact, his first goals in the AHL and NHL came within only a few months of each other.
Toffoli was in his rookie season in the minors, too.
"That's got to be pretty special," Quick said of Toffoli's first goal, which gave the Kings a 2-0 lead in the second period. "You're happy for him that he's able to get it. First of many."
Muzzin whistled a shot from near the point to give the Kings a 1-0 lead on a first-period power play, the only goal they needed to win. It was the 24-year-old Muzzin's sixth goal in only his 25th NHL game, making him the Kings' leader among defensemen.
Muzzin wouldn't be with the Kings if not for a couple of prolonged injuries suffered by a pair of veteran defensemen. He still would be playing with the Manchester (N.H.) Monarchs of the AHL if Matt Greene (back) and Willie Mitchell (knee) were sound.
Toffoli's chance to play in the NHL didn't happen because of injuries, but rather because of a trade Feb. 26 of winger Simon Gagne to the Philadelphia Flyers for a conditional draft pick. Opportunity also knocked when Jordan Nolan didn't play as well as hoped in recent games.
The Kings recalled Toffoli from Manchester on March 10, and Kings coach Darryl Sutter stuck him in the lineup in place of Nolan for Saturday's game against the Sharks. Sutter put a good deal of faith in Toffoli by placing him on a line with Carter and Mike Richards.
"It sure is (a good feeling) for him," Sutter said of Toffoli. "He basically had to just get it up and score. I put him out on the ice on the power play. He should come and thank me."


text:
JAGGER-L ArchivesArchiver > JAGGER > 2000-07 > 0964037495
From: <>
Subject: [JAGGER] Free Databases
Date: Wed, 19 Jul 2000 16:11:35 EDT
As some of you may know, Rootsweb and Ancestry.com have recently merged.
While Rootsweb will continue to function separately by providing us with all
the services, research sources, and over 21,000 genealogical mailing lists
just as it has in the past, the merger has provided Rootsweb listmembers with
a few 'perks' from Ancestry.com.
Starting today and lasting until the end of July, Ancestry.com is opening up
all of their databases to us for free access. They have routinely allowed
free access to all new resources for the first 10 days, and I occasionally
pass that information along to you if it pertains to something of particular
interest. However, until July 31st, ALL of their databases can be searched
for free.
Please don't misinterpret this as a recommendation beyond the free offer, as
I only wish to pass along to you the ability to search records which are
normally open to members only. The signup is very simple...I did it, and
took all morning just to get through the databases beginning with the letter
'A', as the list of records is quite extensive. Browsing further, I found an
actual photocopy of my g-g-grandfather's Civil War pension application.
They also have a free daily newsletter with genealogical articles, lists of
the new 'free for the first 10 days' databases and maps, and research tips
from readers. Many of the little things I post to the list have come from
this newsletter.
The URL for the free offer is:
I deliberated whether or not to forward this offer on to you, but then
decided that you could do a great deal of free research in the next couple of
weeks! I hope each of you will check through what is available, and wish you
good luck in your research. Be sure to let us know any new discoveries!
JAGGER listmgr.
Their notice in today's newsletter.....
Ancestry.com is offering free access to all of its databases through July 31,
Ancestry.com databases currently reference more than 600 million names in
over 2,500 databases, and our goal is to have over 1 billion names online by
Ancestry has been adding databases at a record-breaking pace, and the
genealogical community has been thrilled to see the recent postings of such
landmark databases as the Biography and Genealogical Master Index (BGMI) and
the 1890 Census Reconstruction Project. These are in addition to quality
collections like the PERiodical Source Index (PERSI), AIS Census Indexes, the
Civil War Research Database, Slave Narratives, and the American
Genealogical-Biographical Index, to name a few.
Recent database additions include:
--- Civil War Pension Images Online
--- New York Naturalization Petition Index, 1907-24
--- Gene Pool Individual Records (20 million names in 5 million records!)
--- Canadian Immigrant Records
And there is much more to come! The list of upcoming additions to the 1890
Census Reconstruction Project alone is staggering! (The list is online at:
The upcoming New England database "The Great Migration Begins" will be sure
to thrill those with roots in old New England, and Ancestry.com Images Online
will bring quality images of original records into your own home!
Sign up for free access today at:
To subscribe to this newsletter, visit http://www.ancestry.com/
and type your e-mail address in the box provided,
or send an e-mail message to:
with the word "subscribe" in the subject line.
This thread:
|[JAGGER] Free Databases by <>


text:
2017 Event Calendar
Main Street Zephyrhills is the official visitors' center for downtown Zephyrhills FL. We hope to see you soon in the downtown district.
Our Mission
Main Street Zephyrhills, Inc. is dedicated to providing economic vitality through historic preservation, pride in our quality of life and a strong sense of community.
In the past, the word brought to mind an image of a bustling center of commerce and activity. Too often today, the image is of vacant, deteriorating buildings. Now communities have discovered that with help from Florida Main Street, downtown can thrive again.
Revitalizing Downtown
Throughout Florida, there is a growing interest in improving the appearance and economical stability of downtown business districts. In many small communities, the downtown is in a serious state of decline. Effective solutions to the problems of deteriorating building stock, loss of business and the waning economic strength of downtown are crucial to the survival of the city itself.
There are many reasons for a community to actively encourage the revitalization of their downtown. An economically healthy, historic downtown Zephyrhills:
- Builds a positive image for the community. An attractive downtown reflects a community's confidence in itself and its future.
- Creates job opportunities by attracting new industry and strengthening services and retail job markets.
- Saves tax dollars by stabilizing and improving the area's tax base and protecting the investment already made in downtown infrastructures.
- Preserves the community's historic resources. In an economically healthy downtown, property owners can afford to maintain the historic commercial buildings and preserve an important part of the community's heritage.


text:
I'm 19 weeks and am not sure if I've felt the baby move yet. I could swear I felt some movement around week 16, but haven't really felt anything else recently. I've heard the movements can be very subtle. I also hear 18-22 weeks is the norm, when did it happen for you?
Kathy (33) - married to hubby since Apr '99