text:
Cosplay Central
shopping cart
Spiky, dark rooted hair wigs in a distinguished "Punkish Look". Stretch net under cap for easy fit. **Pink color may be lighter than pictured.
our price: $ 8.79
reg: 11.24
Wig Bad Fairy Black Pink
Free style, free spirit, two-tone wig for that gothic, fairy look.


text:
Processing Time - Orders typically ship in 2-5 business days. Transit via UPS Ground can take up to 6 business days. Braided and custom-made products may take 2 to 3 weeks for delivery.
Free Shipping to Contiguous United States - We do not ship to Alaska, Hawaii or the Caribbean Islands at this time.
Oversized items - Orders that ship freight may take up to 2 weeks from shipment date to be delivered. You will be contacted by the trucking company to schedule a delivery appointment.
Shipping to Canada - Orders shipping to Canada will be subject to a 15% shipping surcharge fee. The shipping surcharge does not cover duties, customs, taxes or brokerage fees which may be charged to you by the shipping courier at time of delivery. At this time we are not shipping to Yukon and the Northwest Territories in Canada.
|Pin It
Safavieh Malibu Shag Malibu Shag Hand Tufted Rug Silver Rug
Item #: 101MLS431C-P Add to Wishlist
Description: This Safavieh Malibu Shag rug offers modern style with ultimate comfort. High density polyester pile with different shades gives this rug a unique peppered pattern look.
- Collection: Malibu Shag
- Brand: Safavieh
- Material: 100% Polyester
- Weave: Hand Tufted
- Styles: Shag & Flokati Rugs
- Origin: China
- Available in the following sizes: 2' 6" x 4', 3' 6" x 5' 6", 5' x 8', 8' x 10', 8' 6" x 12', 7' x 7' Round, 7' x 7' Square, 2' 3" x 7' and 2' 3" x 9'
Price: $68 - $688
I liked the rug. It matched the floor of my bedroom. I was hoping it would be much thicker but it is soft (could be softer).RECOMMENDED: Yes, I would recommend this to a friend.
It was hard to tell what the rug actually looks like from the site photo. It's actually nicer than I expected it to be. It's thick and soft with various colors and types of fibers. The color is a true gray (not blue) and matches the photo well.RECOMMENDED: Yes, I would recommend this to a friend.
I love the rug it looks very nice in my kitchen and soft to walk on.RECOMMENDED: Yes, I would recommend this to a friend.
This rug is thick and the color was accurate from the website picture.RECOMMENDED: Yes, I would recommend this to a friend.
This rug, though a bit darker than I expected, is gorgeous! I've been looking for weeks and weeks for just the right accent rug and none (that I could afford)worked. Buying online felt like a risk because of not being able to see it in person but I was so frustrated by the growing lack of options that I took the chance and know I made the right decision. It's a beautiful rug, the price was right, and the person I spoke to after the rug was delivered (I had a question about how to flatten it) couldn't have been nicer...a real sweetheart! All in all, a very positive experience.RECOMMENDED: Yes, I would recommend this to a friend.
Rug arrived very quickly! It's beautiful and very soft; feels great under the feet. So far it hasn't shed. As far as "natural", it pulls more tan/dark beige; a really good neutral color.RECOMMENDED: Yes, I would recommend this to a friend.
We received this rug in 5 days. We ordered the natural color and we love it! It actually is a 2 tone color of a beige and cream. It is very soft.RECOMMENDED: Yes, I would recommend this to a friend.
Rug arrived in a very timely manor, in great condition. We are happy with the rug, and will order from rugsusa.com again!RECOMMENDED: Yes, I would recommend this to a friend.
arrived on schedule in great condition. Slightly darker than anticipated,(thought it would be a creamier color) but it looks good and seems to be wearing well. We are very satisfied with the rug and service and will look forward to our next order with you. Thanks
This is exactly what we were looking for to put in our kitchen. The quality is excellent and we received the rug much sooner than expected. We would not hesitate to order from RUGSUSA again. Great product!RECOMMENDED: Yes, I would recommend this to a friend.
Beautiful area rug, but take note that if you order the "silver" color, it's more like white with a little black & grey in it. Will probably get dirty, I think a better choice would be the darker grey if it's in a room that gets alot of use. This picture is NOT the same color as the rug in person.RECOMMENDED: Yes, I would recommend this to a friend.
Not quite the color I expected, but quality is good and texture is nice.RECOMMENDED: Yes, I would recommend this to a friend.
Love your products. I'll be purchasing more rugs.Outfitting a nes house. Thanks GloriaRECOMMENDED: Yes, I would recommend this to a friend.
Safavieh's award-winning original collections range from the finest antique reproductions to the most fashion forward, contemporary rugs. Safavieh offers a wide variety of transitional area and accent rugs of both Oriental and contemporary designs. Safavieh also produces a variety of rug designs from American Country styles and 19th and early 20th Century European Art.
Fill out the information below.

subset: commoncrawl


text:
Business & Management
The courses of the Siebel Institute of Technology and World Brewing Academy (a Siebel Institute and Doemens Academy partnership) cover the full spectrum of brewing science and technology. With over 20 courses and programs, we offer more brewing-specific training than any other school in the world. We feature world-class courses at our educational facilities in Chicago, Montreal, and Munich, and we offer the industry's best web-based training programs.
This module is part of the advanced-level programs.
As such, seats in this program are first given to those completing the program on a continuous basis, with any remaining seats going to those taking the course as an individual offering. Your registration with course deposit for this course will make you eligible for a seat should one become available, and your deposit will be refunded should a seat not become available. You may cancel your registration at any time before the start of the course for a full deposit refund should a seat not be available
Entry-level courses
Students require no prior brewing or distilling knowledge.
Intermediate-level courses
Prior brewing knowledge is not required, but students will benefit from existing knowledge of brewing technologies and/or related sciences.
Advanced-level courses
Course/program requires students to have specific knowledge of brewing technologies and/or related sciences in order to enroll.
To assess your readiness to participate, please contact John Hannafan requesting an assessment review for your chosen course/program.


text: 5 TRULY BRILLIANTJokeyJoe | 25/08/2009 | See all JokeyJoe's reviews (14)Top 100 Gadgets Reviewer Worth every penny, these sturdy bookends are soooo cool. Iv'e had loads of comments on how brilliant they look. They look even better in person than on the tinternet. NOTICE: The stainless steel plates that Morph and Chas stand on, are not stainless steel - they are the same material and colour as the characters themselves (Which makes them better quality and more sturdy)


text:
|Top Seller
|Branded Storefront
|Custom Branding based on your specification
|Access to the Frooition Design Management Listing tool
|eBay Store / Shop Design
|eBay Listing Template
|Dynamic Features (such as Shop Categories)
|Brand Search Boxes
|Hi Visibility Search Boxes
|Horizontal Sub Header Links
|Side Promotion Graphics
|Rotating Central Imagery (Hero)
|Sub Category Boxes
|Custom "Splash" Store Page
|Custom Listing Design
|Drag & Drop store layout
|WYSIWYG Store page creator
|Upload custom promotion graphics
|Create dynamic product display panels
|Create fading graphic hero's
|Filter which products are shown on your store pages
|Includes 12 Months Dynamic Delivery
|Includes 12 months image hosting
|Includes 12 months bulk revision
|Design flows across search pages
|New, more flexible, eBay store format
|Advanced eBay Design Example
|Topseller eBay Design Example
|Signature eBay Design Example
|Branded eBay Design Example
|More Info
|More Info
|More Info
|More Info
|After using the new branding, I can clearly see the increase in sales. I have never been happier!
Once again, thank you so much for the fantastic design and amazing service from beginning to end.
|I thought Id give you some great news - The stores only been on the listings I have up for a few days, and I must say I've already seen some very noticeable results with sale volumes,
Thanks very much for all your help
Qualcom Direct
|I can't say enough about the excellent work that Frooition has done on my design. It was an absolute pleasure to work with them, the designer listened to our thoughts and suggestions and far surpassed my expectations.
I highly recommend that you use Frooition for your eBay and Facebook design.
Oz Games
|Not only are they great designers they also bent over backwards for me, if we wanted to change things and add new things they would do it with no questions asked.
As soon as we had this implemented we have seen an increase if sales month on month. Our web-store has seen an increase hit in traffic and more sales. I really could not recommend them enough. Thank you Frooition!!!
Digital Wave
|Frooition's expertise helped us take our business to the next level, we now have an established brand and are recognised as one of the foremost suppliers of hip-pop jewellery.
|After using your service, I can clearly see the increase in sales. I have never been happier! Once again, thank you so much for the fantastic work and amazing service from beginning to end
|I was initially concerned about how much time it would take to prepare an ad with the Frooition system, but again, I am more than pleased. The template is extremely easy, and it saves me SO MUCH time over the template service I was using previously. This time savings is money in the bank too, because I can be so much more productive.
|We dealt with a member of their creative team and wow can they deliver. They listened to what we wanted & gave our store a complete refreshing makeover & nothing was ever any trouble. The price was fantastic & has helped with record sales this year in a hard market. Thanks Frooition all the best for the future
Ride the Waves


text:
Aftershock: Beyond the Civil War DVD
Sale Price: $14.98
To Order by Phone Call 1-800-933-6249
- Additional Details
- Format: DVD
- Rating: Not Rated
- Number of Discs: 1
- Run Time: 90 Minutes
- Region: Region 1
- Aspect Ratio: Fullscreen
- Language: English
- Studio: A&E Home Video
- DVD Release Date: April 24, 2007
- Audio: ENGLISH: Dolby Digital Stereo
- Cast: David Padrusch
- Genre: Documentary
- Color: Color
- Includes:
· Bonus Documentaries: Images Of The Civil War and Tales Of The Gun: Guns Of The Civil War.
- Release Date: 2006
The aftermath of the War Between the States was for many as terrible as the hostility itself. This riveting DVD presents the unvarnished story of the traumatic Reconstruction period.
- Slavery was not wiped out by the Civil War, only driven underground.
- The post-war chaos was a breeding ground for opportunists from criminal to political.
- Surviving the Civil War was just the beginning of a terrible time of suffering.
The Civil War was only half the battle.
When General Robert E. Lee signed the terms of surrender in Wilmer McLean's home in Appomattox, Virginia, it marked the end of a terrible period of conflict that nearly destroyed this young country. But it also marked the beginning of a period of recovery that was in many ways as painful as the war itself.
Now, THE HISTORY CHANNEL® shows in stunning detail the trials that befell America as it healed during the Reconstruction. Blood continued to flow freely long after peace was made. Murder, terrorism and chaos filled the void left by the devastation of the war. "Free" black men and women remained enslaved. Race and tax riots, marauders and insurgents, profiteers, carpetbaggers, the KKK and Jesse James all contributed to the turmoil.
Using archival images, accurate dramatizations and the latest scholarship, AFTERSHOCK: BEYOND THE CIVIL WAR is a comprehensively informative and dramatic account of this terrible, shameful episode in American history.


text:
Cage Rage is the UK's leading Mixed Martial Arts event, bringing the best fights, the best fighters, and the best all-out fighting action. Witness the biggest names in the UK facing up against some of the most talented fighters in the World. Cage Rage has it all!
One of the most popular fighters in the World - the legend that is Ken Shamrock makes his Cage Rage debut and is matched up against none-other than Cage Rage's very own heavyweight fan-favourite, Robert Berry! These two mighty goliaths will stop at nothing for victory, and over 200kg of muscle will clash in an epic battle!
Ken Shamrock's son also makes his Mixed Martial Arts debut when Ryan Shamrock goes up against Giorgio Andrews. Also, in a war between the hottest heavyweights in the UK, Rob Broughton takes on Neil Grove, whilst Gary Turner squares up to Mustapha al Turk in a fight that will go down in the history books!
Ken Shamrock vs Robert Berry
Ryan Shamrock vs Giorgio Andrews
Gary Turner vs Mustapha al Turk Pierre
Guillet vs Tom Watson
Masakazu Imanari vs Jean Silva
Rob Broughton vs Neil Grove
Ivan Serati vs Roman Webber
Henrique Santana vs Michael Johnson
Aisling Daly vs Aysen Berik
Jake Bostwick vs John Phillips
Jon Hathaway vs Marvin Arnold
Fighter Interviews
We do our best to provide accurate sizing info for all items of MMA Clothing & Equipment that we sell at MMA Universe.
You can find our sizing information here
Should you be unable to find the information you need you can contact us at any time, we would be delighted to help you!
We do our best to ensure that our shipping prices are as fair and competitive as possible. We offer four tiers of delivery each with their own benefits and we offer free delivery options with orders of £50 or more.
If you place your order with us before 2pm GMT on Mon-Fri, we guarantee to ship your order the same day. Orders placed after this time may not be processed until the next available working day (but we'll do our best to get your order on it's way ASAP). Our typical delivery times are:
|United Kingdom:
|Within 48 Hours of shipping
|Within Europe:
|Within 5-7 Days of shipping
|Outside of Europe:
|Within 7-10 Days of shipping
MMA Universe have simple returns policy where if you are not 100% satisfied with your purchase, you can return it within 14 days of receiving it for any of the following:
- Exchange your purchase for another size or colour, or a new item entirely.
- Return your purchase for MMA Universe Store Credit.
- Return your purchase for a refund.
- Return your purchase for a replacement if it is damaged or faulty.
Items to be returned for exchange or refund must be unworn and in the original packaging, unless faulty, in which case please wash them first!You can find more information about our returns policy here


text:
About Us
Reviews (0) |
Did you buy this item?
Add your review
Item # BK8A--LARGE
Shipping: Priced In Cart
Price: $316.15
Non-Returnable Product
Quantity Price Discounts
This professional grade kit has everything--minus the bees--to get you started on your beekeeping adventures. It is made from long-lasting 7/8" Eastern Pine and has all the necessities from top to bottom. We've added a Varroa screen for Integreted Pest Management (IPM) and a 3 gallon hive top feeder. It comes either fully assembled like this (all hive bodies, frames and supers are already assembled and ready to use) with plastic frames or unassembled with wooden frames and crimp-wired wax foundation.
Kit components:Galvanized Telescoping Outer CoverWooden Inner CoverBeeMax® Hivetop Feeder w/drown guard2 Medium Supers16 Plastic Medium Frames 2 Deep Hive Bodies16 Plastic Deep FramesReversible Bottom Board10" Hive ToolStainless Steel Smoker w/Heat ShieldBeginning Beekeeping BookLeather GlovesHard Plastic HelmetRound Tie-Down VeilPlastic Queen ExcluderVarroa ScreenVarroa Monitor and Debris Tray
Dimensionalized shipping rates apply.
Note: Please no substitutions for the items in this kit.
Assembled Supering Kit - 8 Frame
10" Betterbee Hookend Hive Tool
Shop Safely with
We Accept


text:
|A delicious stew with no potatoes or carrots, perfectly satisfying for Phase One!
(For January I'm sharing A Month of Daily Phase One Recipes, and this stew from the very early days of my blog is a perfect example of how recipes can be adapted to make them suitable for Phase One. This is the first recipe for January 2013, but eventually you can use that link above to find all the recipes, and you may also want to check A Month of Daily Phase One Recipes 2012.)
Starting Phase One will be easier if you follow a mental process of thinking about all the really good foods you can still eat, and plan recipes or menus around those foods. This delicious Leftover Roast Beef Italy Stew is a perfect example, and with all the flavor from green pepper, mushrooms, roasted tomatoes, oregano, and basil, you wont' miss the potatoes or carrots in this stew. The recipe is something I created when I had leftover roast beef and remembered something I saw in a magazine at my brother Rand's house. At the time I was a brand new blogger, and didn't write down the source for the inspiring recipe. I do like pot roast, but I don't much like roast beef sandwiches, so this seemed like a perfect way to turn leftover roast beef into something special.
Leftover Roast Beef Italian Stew
(Makes about 2-3 servings, recipe can easily be doubled. Recipe created by Kalyn with inspiration from a magazine at Rand's but she can't remember what it was.)
1/2 onion chopped
1/2 green pepper chopped (or more)
1 T olive oil
8-10 oz. leftover roast beef or steak (about 1 1/2 cups diced beef cubes)
2 cups beef stock (or 1 can beef broth plus a little water)
1 cup slow roasted tomatoes (or 1 can diced tomatoes)
1/2 T dried oregano
1/2 T dried basil
1 cup mushrooms, cut in large chunks
1-3 T chopped fresh basil (or frozen chopped basil.)
South Beach Suggestions:
Nutritional Information?


text:
|Mobile Site
|Caption Comp
|Monthly Poll
|Sudden Death
|Colour Key
|Cookie Usage
|Series :
|The Next Generation
|Rating :
|Disc No :
|Episode :
|First Aired :
|3 Feb 1992
|Stardate :
|Director :
|Robert Wiemer
|Year :
|Writers :
|Pamela Gray, Shari Goodhartz, T. Michael
|Season :
|Guest Cast :
|Moral :
|Riker claims that he does not know if Troi can hear him whilst in a coma in this episode. Even today you can tell if a person can hear a sound by examining their brain wave patterns - this is how they diagnose deafness in very young children. Has Starfleet lost this ability? Or does it just not work on Betazoid women?
|Great Moment :
|Picard's hair in Beverly's flashback.
|Body Count :
|Zero deaths, though there are a number of comas.
|Factoid :
|Although only three characters have memory flashbacks in this episode, such scenes were written for every major character.
|Quote :
|"Earth was once a violent planet too. At times, the chaos threatened the very fabric of life. But like you, we evolved. We found better ways to handle our conflicts. But I think noone can deny that the seed of violence remains within each of us, We must recognise that, because that violence is capable of consuming each of us." - Picard to Tarmin
While transporting Ullian delegates to Kaldra IV Enterprise crew members begin suffering mysterious telepathic assaults.
|Copyright Graham Kennedy
|Page views : 3,268
|Last updated : 9 Oct 2003


text:
Kathy wishing you the happiest birthday every!!
May your creative juices flow brilliantly over the next year...
May you loose all weight you wish for...and may it slide right off easily!! LOL!! or maybe I should say float off since water aerobics is your choice of torture...LOL!!!
I wish you health, wealth and heaven when you die...how can I wish you more?? (this last part is an irish verse) :-)
Huge hugs


text:
<ac:macro ac:name="toc"><ac:parameter ac:name="type">list</ac:parameter><ac:parameter ac:name="maxLevel">3</ac:parameter></ac:macro>
<ac:macro ac:name="note"><ac:parameter ac:name="title">Participate in the Discussion</ac:parameter><ac:rich-text-body>

Please participate in the discussion! You can either do so in comments to these pages, or by subscribing to the email@example.com – simply send an email to firstname.lastname@example.com!
</ac:rich-text-body></ac:macro>

Zend Framework has grown substantially and organically throughout the 1.X series of releases.

The result has been a framework that is immensely powerful, broadly appealing, and enormous in scope – but also one that is cumbersome and difficult to learn, distribute, and extend, and one that is becoming less and less performant. Additionally, since Zend Framework has experienced large adoption, this has led us to re-evaluate a number of design decisions – but the inability to break backwards compatibility has made it impossible or difficult to create better implementations.

The primary thrust of ZF 2.0 is to make a more consistent, well-documented product, improving developer productivity and runtime performance.

The following document serves as a narrative detailing the various goals of Zend Framework 2.0. We will be gradually filling in an implementation plan for each set of goals so that we can measure the success of the effort.

General Goals

Ease the learning curve

Make extending the framework trivially simple

Improve baseline performance of the framework

Simplify maintenance of the framework for the core team and contributors

Be an exemplar of PHP 5.3 usage

Provide mechanisms for using just the parts of the framework needed

Ease the learning curve

In late 2009, we did a survey of framework users to determine what they use,

what environments they use, and what their needs are. The top issue, bar none,

was the difficulty of learning the framework. Some of these issues include:

Difficulty in the "first hour" with the framework. Many of these questions have been addressed in the revised "Quick Start" shipped with 1.10, but additional issues remain: how to setup vhosts on non-Apache web servers, how to follow the quick start without a dedicated vhost, and problems arising from differences in operating environments.

Uncertainty about the "next steps" following the quick start. Developers are unsure how to go about using different components to create a cohesive application. Again, first steps at alleviating this concern have been taken with 1.10 with the "Learning Zend Framework" section of the manual. However, these are largely disparate tutorials, and don't show full development on a single application.

Inconsistent APIs in the source code itself. One component may use "plugins," another "helpers," and yet another "filters." One component may utilize fluent interfaces, another not. One component may allow MixedCase plugin names, while another only allows Titlecased. One component may use a broker for accessing helpers, while another delegates to them via __call(). One component may allow camelCasedOptions, while another only allows underscore_separated. One component may allow passing an array of options only, while others allow passing an array or a Zend_Config object. The list can go on for quite some time.

Uncertainty about where extension points exist, and how to program for them.

Confusion over whether they can use Zend Framework only as an MVC stack or as individual components.

MUST create two separate quick start tutorials: one that covers using individual components of Zend Framework, and another covering creation of a basic MVC application. In both cases, the tutorials:

MUST explicitly indicate the expectations of developer knowledge. E.g., "developer should be familiar with PHP 5, OOP, and have a basic understanding of autoloading; additional, some knowledge of Apache and configuring virtual hosts is assumed."

MUST have reproducible steps that, if followed, will return the same results. Minor variations for common operating system environments should be covered (e.g., differences between linux, mac, and windows environments).

MUST clearly identify the next steps a developer should take, and link to related references.

Development of a set of cohesive tutorials covering intermediate and advanced Zend Framework topics. To achieve this we:

MUST identify common development problems for Zend Framework, and the most common patterns used to address them.

MUST write a sample application that illustrates these problems and solves them using the patterns identified.

MUST have a clear narrative showing step-by-step construction of the application, one problem/pattern at a time.

The reference manual:

MUST clearly state the assumptions and use cases for each component. As an example, the various url() helpers currently allow passing a named route as an option. However, many developers do not understand that if none is provided, then it will use the currently matched route. This leads to a difference between developer expectations and code expectations, which has led to a number of issues in the tracker. Simply documenting these, as well as concise use cases, should alleviate the issues.

MUST have consistent formatting for each component, for predictability.

SHOULD provide an overview

SHOULD provide expected arguments and return values, as well as exception conditions

SHOULD provide one or more usage examples

COULD provide narrative, but does not need to

Address the various API consistency issues:

MUST standardize option casing

MUST standardize language and APIs surrounding the various extension points

SHOULD attempt to standardize APIs for passing options to components

SHOULD attempt to identify and implement common API patterns throughout the framework

Make extending the framework trivially simple

Extending Zend Framework is relatively easy already. However, there are a few notable cases where it is difficult, and some of these cases are found in many places in the framework.

These include:

Singletons. Many singletons have a lot of behavior coded into them, making it difficult, if not impossible, to provide alternate implementations. Examples include Zend_Controller_Front, Zend_Auth, and Zend_Session.

Use of abstract classes instead of interfaces. Many ZF components define rich abstract classes with a plethora of behaviors. While these may be extended and alternate implementations provided, doing so often requires accepting functionality you don't need, or needing to overwrite large sets of functionality you don't want. In many cases, the consuming classes only rely on a small subset of behaviors.

Hard-coded dependencies. In many cases, components have hard-coded dependencies, making it impossible to alter behavior without extending the class to add your own dependency or to allow injecting the dependency.

Failure to identify processes that could benefit from collaborators. As an example, many of Zend_Db's methods could benefit from user extension – for instance, to allow checking for and writing to a cache, normalizing values prior to insertion, etc. In order to do this now, users must extend the existing classes, leading to difficult to traverse hierarchies and reducing re-usability. A plugin/filter system could alleviate these issues easily.

MUST Eliminate singletons where possible; when not possible, push behavior into collaborating objects.

MUST identify the essential interfaces for each component and subcomponent, and typehint on these instead of the existing abstract classes.

MUST remove hard-code dependencies and allow for dependency injection.

MUST examine each component and address the need for collaborators.

SHOULD add a section to the documentation for each component, showing in a consistent structure the component's support for extension, plugins, and hooks.

Improve baseline performance of the framework

Baseline performance of Zend Framework applications has been getting worse with almost every release; even when gains are made, new processes added in new releases lead to degradation. While ZF started as a fairly nimble framework, it is now among the slower alternatives available, when using the supplied MVC stack.

The goal of ZF 2.0 is to identify causes of performance issues and implement code changes to mitigate them until ZF is competitive with any other PHP framework of similar capabilities.

MUST improve the baseline performance by 200-300% over the 1.x series, and competitive with the more agile full-stack frameworks currently available, including Solar and Symfony 2.

MUST provide deployment-time tools for optimizing performance in production

MUST provide documentation, tutorials, and examples to help developers follow best practices for performance.

Simplify maintenance of the framework

As of the time of this writing, Zend Framework consists of over 2 million lines of code, including over 14k unit tests. The internal team at Zend consists of a project lead and two engineers, while actual contributors number in the dozens. Contributors come and go, largely based on their interest in specific components and the time they have to devote to the project. High turnover of maintainers and lack of availability from maintainers, both internally and amongst contributors, has led to many orphaned components and/or components with large numbers of issues filed against them.

Additionally, with the growing complexity of many of the components, often due to differing expectations between different end-users and the original designs, we often get internal conflicts within components, where resolving one issue or addressing one feature requests can spawn regressions for existing functionality.

Another barrier has been actually getting contributions into the framework. Currently, we only offer SVN access on a case-by-case basis, which leads to developers posting patches as comments or attachments to the issue tracker. Often, the best way to really evaluate these patches is to apply them and run unit tests – and this method of obtaining the patches is inefficient.

When it comes to writing patches, many developers are unsure how to do so, or where in the tree to generate the diffs. As a result, often the patches submitted need to be doctored in order to be usable. Subversion does not help here, as svn diff can be done at arbitrary levels, and will not diff from the tree root.

Collaborating on complex components or component development is also often difficult, as there are no good conventions for maintaining separate branches in the ZF repository. As a result, many developers will do feature/component development in their own version control systems, and point developers to these to test. This can lead to overhead if they use a different class prefix during development versus once the component is pushed into the ZF repository, as well as if the original development is done in a different version control system.

Finally, there are a number of components for which 3rd party code offers more comprehensive solutions. Users may turn to these, or compare ZF components with them when evaluating solutions to their application needs.

SHOULD migrate to a distributed version control system

SHOULD be a system many ZF developers are already familiar and/or *comfortable with

SHOULD have the ability to specify multiple remotes per local repository

SHOULD create patches from the repository root by default

SHOULD support some method of verifying committer identity, to allow easy verification of CLA status when merging to the canonical repository

SHOULD include well-defined interoperability and compatibility with existing third-party libraries and frameworks.

This COULD be via consuming these third-party solutions

This SHOULD include helping define and follow interoperability standards, such as the common naming schema to allow common autoloading capabilities.

Be an exemplar of PHP 5.3 usage

One goal of Zend Framework was to advance the usage of PHP 5 and establish best practices surrounding the usage of PHP 5. To a large extent, ZF has achieved this goal (along with a handful of other projects).

PHP 5.3 was released mid-2009, and with it a myriad of new features were introduced: closures/lambdas, namespaces, late static binding, goto, and more. Many of these new features were introduced at the insistence of framework developers, as they can assist in making code more maintainable, concise, and readable.

Simply stated, Zend Framework 2.0 MUST be an exemplar of PHP 5.3 usage.

MUST use namespaces throughout the framework, to mitigate naming collisions with userland code and third-party code.

MUST remove all create_function() constructs and replace them with closures

MUST evaluate the framework to identify areas that could benefit from other new language features.

MUST NOT use new language features just for the sake of using them. They should be utilized only where they make sense.

SHOULD be a showcase for improving code through refactoring, which is itself a strength of PHP.

Provide mechanisms for using just the parts of the framework needed

One criticism often levied against Zend Framework is that it is "bloated." In most cases, the accusers are critical of the shear breadth of the framework – they do not want to install the entire code base when they only need one or a handful of components from it.

Additionally, many developers are using individual Zend Framework components within larger applications, sometimes written in other frameworks. ZF should support and encourage such use cases, and make it trivially easy for developers to fetch the components they wish to integrate.

On a related note, when pushing an application to production, often there are huge swaths of the framework that must be pushed that will never, ever be used, which wastes bandwidth, time, and disk space.

We have traditionally shipped the entire framework because it makes sense to have the entire framework available; if you need a component, you don't need to fetch it before using it. However, with the shear breadth of the framework, and the many uses to which developers are putting it, the time has come to enable developers to select individual components.

MUST provide code infrastructure to support packaging

MUST use namespaces and good component design to ensure components are properly encapsulated

MUST write tools that can automatically determine dependencies for components

SHOULD write tools for automatically creating packaging information (e.g., files necessary, component name, release version, etc.)

SHOULD create a PEAR and/or Pyrum channel for distributing packages

SHOULD create a number of meta-packages or bundles for common functionality; e.g., "MVC", "I18n", etc.

Development Objectives

Programming by Contract

Favor the explicit over the magical

Zend Framework is often accused of being "bloated". When pressed, those who claim this will point to two factors: overall size of download, and the fact that most ZF components try to cover absolutely every use case possible, while specializing in none. The first factor is a straw-man; with a comprehensive framework such as Zend Framework, one should expect the download size to be fairly large.

The second factor, however, is very much accurate. It is also the source of our large number of issue reports. Developers consistently want a component to cover "just one more" use case, and adding support for it may then lead to inconsistent or undesired behavior in other use cases, leading to a spiral increase in reports.

Additionally, we have maintained a number of "hacks" and structures within the framework that can either be eliminated or replaced with language features available in PHP 5.3.

Focus on Core Components

Our goal with 2.0 should be to identify the essential use cases for each component, and what specific problems need to be solved. Components should be designed in such a way as to allow injection of alternate implementations, either through extension or implementation of interfaces. Any additional use cases can be covered either in alternate implementations shipped in the framework, or in custom, userland implementations outside the framework. The focus on maintenance should be on the core functionality of the component (and framework), no more, no less.

Additionally, we should examine components carefully to determine if a need for the component still exists, and whether the component is still under active maintenance. If the answer to either question is "no," we should consider removing the component.

Make Code Readable

One of the "rules" of Zend Framework 1.X development was that all code should have vendor and component prefixes. In fact, a 1:1 relationship between the classname and the filename has been enforced. This is a good practice overall, but with the use of "vendor prefixes", it has led to some verbose and difficult to read code.

For instance, to refer to any given class name, you must use the full classname. While this is not problematic for top-level classes such as Zend_Loader and Zend_Registry, once you get much deeper, the classes become unwieldy, and the prefixes tend to distract from the actual function of the given class: e.g., Zend_Controller_Action_HelperBroker seems like overkill for a class that is simply a "Broker".

Additionally, this leads to over-long lines. If I need to reference more than one classname in a given line, I'm almost guaranteed to exceed the recommended line length and/or split the line into multiple lines. This leads to reduced comprehension for those trying to read and understand the code. Class names, method names, and variable names should be brief. Namespaces in PHP 5.3 can help make this a reality for classnames.

Finally, there is inconsistency in the framework with how code is formatted. While we have a published Coding Standard, we do not always follow it. Additionally, some practices are considered "optimal", but not "required" – practices such as alignment of operators, keeping variable names meaningful yet short, consistent indentation, etc. For some detailed examples and discussions of why, read the Seven Pillars of Pretty Code. These details need to be made required, and enforced via peer code reviews or pre- and/or post- commit hooks utilizing a utility such as PHP_CodeSniffer.

Identify Common APIs

Within the framework, we have a variety of common practices that have slight variations. As examples:

Both action controllers and views can make use of "helpers" – but the mechanisms of how these work differ (action controllers use a "broker"; view objects call on helpers via method overloading).

View objects allow post-filtering of rendered contents – but the filters themselves do not follow the same interface as those found within the Filter component.

Having differences between APIs makes learning the framework more difficult. We must identify those areas that are functionally similar, and refactor them to use the same common basis. This will ensure consistency across the framework, which will make learning and mastering the framework easier.

MUST remove obsolete, deprecated, or unmaintained components

MUST rely on PHPUnit features to automate and simplify test suite maintenance

data providers

@group annotations

TestAsset namespaces

MUST make code more consistent

Consistency in naming conventions

Classes are nouns, methods are verbs

Interfaces are nound or adverbs

Abstract classes are predictably named

Interfaces for any component that could have multiple strategies

MUST establish well-defined guidelines regarding code formatting to enforce readable code

MUST migrate code to use namespaces

MUST utilize a code sniffer, and define rules that correspond to our coding standards

MUST define and enforce consistent APIs; as examples:

Leverage language features when possible to assist (__invoke(), closures, etc)

Programming by Contract

Programming by Contract asks

developers and architects to create solid interfaces and answer the following

questions during development:

What does it expect?

What does it guarantee?

What does it maintain?

(bullet points copied verbatim from the wikipedia article)

Basically, any time an object uses collaborators, we should be defining

interfaces to allow developers to inject their own implementations. These

interfaces must be well-designed to ensure that we accurately capture the

requirements of collaborators.

As an example, in the 1.X series of Zend_Controller, we have abstract Request and Response objects. These have grown over time to include additional functionality useful to developers, but the core functionality used within the ZF components themselves is quite minimal. Ideally, we would create lean interfaces capturing the behavior necessary for Request and Response objects to work in the ZF MVC – thus making it easier for developers to slip-stream in their own implementations. Any functionality beyond what is defined in the interface would be relegated to individual implementations, and likely through collaborator objects to ensure that alternate implementations don't break additional functionality.

SHOULD adhere to SOLID principles.

All components MUST allow for dependency injection.

When collaborators are defined for a component, collaborators SHOULD follow a defined interface; if an interface does not exist, one SHOULD be defined.

COULD implement a Dependency Injection container or utilize one from a third party source (such as Symfony Components).

Favoring the Explicit

One obstacle new ZF developers face is identifying the source of functionality within the framework. One prime example is view helpers. As an illustration, consider the following example code from a view script:

<ac:macro ac:name="code"><ac:default-parameter>php</ac:default-parameter><ac:plain-text-body><![CDATA[
<?php echo $this->headStyle(); ?>

Developers using an IDE can determine quickly that $this refers to the view object, but, unfortunately, most IDEs cannot determine the source of the function headStyle() – because it does not exist in the view object. The new developer may then turn to the API documentation – and fail to locate the method. If they're familiar with the concept of overloading, they may look at the __call() method finally, and discover that it proxies to view helper objects, but then they need to determine how view helpers are loaded and executed. All-in-all, it adds a ton of overhead when trying to learn the framework.

Additionally, "magic" methods such as _call(), get(), and _set() have performance implications; they take roughly 6x longer to execute than simply calling a standard method. By favoring explicit calls, we can likely radically improve the baseline performance of the framework.

In the above example of view helpers, how might we change the design to be more explicit? One potential solution would be to introduce a "helper broker", and use it to access helpers. Some use cases might look like this:

<ac:macro ac:name="code"><ac:default-parameter>php</ac:default-parameter><ac:plain-text-body><![CDATA[
$view->broker()->attach('greeting', new MessageHelper());
// Proxy execution through the broker
echo $view->broker()->execute('message', 'world');
// Execution of an interface method on a helper pulled from the broker
echo $view->broker('message')->execute('world');
// Execution of an arbitrary method on a helper pulled from the broker
echo $view->broker('message')->greeting('world');
// Retrieving a helper from the broker, and acting on it
$helper = $view->broker('message');
echo $helper->execute('world');
echo $helper->greeting('world');
echo $helper('world'); // using __invoke()

In all such cases the user can easily traverse the API and also get assistance from the IDE; all calls (except the last example, using invocation) use explicit methods, with clearly-defined return values.

This explicit approach is slightly more verbose than using the magic methods, but should ensure that code is simpler to understand, more consistent to use, and more easily maintained.

Evaluate all uses of __magic_method() calls, and determine if they may be refactored to remove them.

Where we determine magic methods are necessary, their usage should be well-documented

May 27, 2010

Glad to see these requirements for ZF2! Can't wait to test the first implementations.

Concerning the Dependency Injection Container, I have worked a lot on integrating the Symfony DI Container with ZF. I have integrated it into Zend_Application and into the dispatcher to let the container manage the controllers lifecycle and their dependencies. I have also developed an annotation loader for Symfony DI Container to allow service definition by annotation.

I ended with a really solid, highly configurable, decoupled, flexible, evolutive and testable multi-layered PHP architecture that I use in my professional and personal projects. I have also developed a Doctrine 2 integration into ZF and this multi-layered architecture with generic service and scaffolding (for forms, services, controllers and views): it works very well! You can check my code on my GitHub: http://github.com/loicfrering/losolib.

Here is an example of what I can achieve with the DI Container:

<ac:macro ac:name="code"><ac:default-parameter>yaml</ac:default-parameter><ac:plain-text-body><![CDATA[
auth.adapter.entityName: Application_Model_User
auth.adapter.identityField: email
auth.adapter.credentialField: password
class: LoSo_Zend_Auth_Adapter_Doctrine2
arguments: [@em, %auth.adapter.entityName%, %auth.adapter.identityField%, %auth.adapter.credentialField%]
class: Zend_Auth
constructor: getInstance
<ac:macro ac:name="code"><ac:default-parameter>php</ac:default-parameter><ac:plain-text-body><![CDATA[
- @Service
class Application_Service_AuthService
- @var Zend_Auth
- @Inject auth
protected $auth;
public function setAuth($auth)Unknown macro: { $this->auth= $auth; return $this; }
- @var Application_Service_Doctrine_UserService
- @Inject
protected $userService;
public function setUserService($userService)Unknown macro: { $this->userService = $userService; return $this; }
- @var Zend_Auth_Adapter_Interface
- @Inject auth.adapter
protected $authAdapter;
public function setAuthAdapter($authAdapter)Unknown macro: { $this->authAdapter = $authAdapter; return $this; }
protected $user;
public function authenticate($username, $password)Unknown macro: { $this->authAdapter->setIdentity($username) ->setCredential($password); return $this->auth->authenticate($this->authAdapter); }
public function hasIdentity()Unknown macro: { return $this->auth->hasIdentity(); }
public function getIdentity()Unknown macro: { return $this->auth->getIdentity(); }
public function getIdentityAsUser()
if (null === $this->user)Unknown macro: { $this->user = $this->userService->findOneByEmail($this->getIdentity()); }
return $this->user;
public function isIdentifiedUser($user)Unknown macro: { return $user->getEmail() == $this->getIdentity(); }

To conclude I think that a DI container is really pertinent to PHP and ZF and I'd love to see one in ZF2.

I'll be happy to debate about the community interest for a DI container in ZF and ZF Core team thoughts on integrating a DI container into ZF2.

- @Service
May 28, 2010

"To conclude I think that a DI container is really pertinent to PHP and ZF and I'd love to see one in ZF2."

You bet!

+ Service-Layer usage (softly) forced by default-application-layout and abstract fwk classes & interfaces to make life easier and services more standardized

+ Annotation-based dependency injection in controllers (services, models, helpers)

Cheers,

May 31, 2010

Even though it's stated that the contributors are very few and the first mentioned goal is to "Ease the learning curve", I interpret this document as an active step towards more rules and angles to get caught in. What is the strategy to learn ZF more easily? I don't think another quick start will get us very far.

What I do think would help:

Get people to framework.zend.com: have a forum which helps people gather around instead of spreading them out, hire the guy of zendcasts.com, build a serious version of zfsnippets.com with unit tests, host more slides (slideshare is a goldmine, so's the official webinars but oh so few) - in short, a little bit more of web 2.0's social side. There's so much good stuff in personal blogs out there that risks never being found in time, possible nail on the head: Matthew Weier O'Phinney's blog - much more involvement from users than on the official devzone (possibly a bad comparison but you get my point), and also often a really relevant source for day-to-day use.

Key point: ZF strongest point is the quality of its code, let it stay that way but a team of 10 people doing QA/contributing to the ideas of 1000's would make the project go way faster forward.

— switching mode

(Small standards) I'd like to see in ZF2:

make all strings constants instead, for code completion, phpdoc and typo-freeness (would break on failure). Zend_Date is ace.

include faulty arguments together with each exception thrown

Cheers from an happy end user who wants to find more time fiddling with ZF and less time googling.

Jun 07, 2010

make all strings constants instead

 I 100% agree. I much prefer to see constants used instead of a generic string even if the string itself is very descriptive.

This may be debatable, but I actually find the current "Favoring the Explicit" section somewhat hypocritical. All of the calls are just arbitrarily named strings. I would have preferred to have seen almost all of those strings be replaced with a constant that were explicitly associated with the method/object it was called on/from (basic example):

$view->broker()->attach('greeting', new MessageHelper());

echo $view->broker()->execute(MessageHelper::message, 'world');

Jul 27, 2010

The keys need to be managed, you can't have multiple helpers with the same key. This makes it cumbersome to use integer values. String values are a little easier to keep track of as human beings, but what is preventing you from using the string value? A string is a constant, just not a class constant.

Another thing one might consider is keys generated by the broker. The problem with that approach is that you no longer know what key references what helper, unless you keep a reference, in which case you might as well keep a reference to the helper object, and avoid keys all together.

The last option I can think of is a static key that isn't user devised and unique for each class. Say, the (full) class name?

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
public static function getName(){
return _class_;

I don't like the "execute" method, as that would require call_user_func, I'd rather have a little train wreck:

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
use some\name\space\MessageHelper;
echo $view->broker()

As an added bonus, the use statement makes it clear which helper you're actually using.

Of course the view can delegate to the broker making it shorter and more explicit:

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
use some\name\space\MessageHelper;
echo $view->getHelper(MessageHelper::getName())->world();

Attaching is easier, because the key is static:

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
$view->attachHelper(new MessageHelper());

Mocking is easy as well:

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
use some\name\space\MessageHelper;

This of course only works with stateless helpers, but that's the whole point: if the helpers were stateful, we wouldn't want a reference to the same object, we'd construct a new one.

Jul 27, 2010

Zend_Date is ace? Zend_Date is fundamentally flawed: it should be a value object.

EDIT: Btw, where do I complain about Zend_Date not being a Value Object?

Sep 26, 2010

You took that out of context. I would agree with you that Zend\Date should be a value object, but the use of constants in Zend\Date is suitable imo.

Jun 04, 2010

I personally believe the best way to ease the learning curve is to improve documentation. The current documentation is good, but sometimes inconsistent in quality and needs to be improved to help inexperienced developers to learn the framework. You should consider hiring a UI / UX expert to redesign the manual and some technical writers to rewrite some parts of the documentation that are lacking. Either that, or assign the better writers among the team to write the documentation.

Of particular note is the quickstart guide, which while an improvement on having no such guide is not ideal as it is. It targets linux system specifically while leaving small notes for other systems which are not very helpful unless you understand exactly what is expected. The entire part on vhost is confusing to most new developers, and is completely unnecessary as you can run multiple Zend Framework projects from different directories on the same (default) document root - which should be the simplest method for inexperienced developers (especially for the development machine or shared hosting).

I've been a happy user since version 0.2, and I'm really glad that Zend is supporting the framework into its next evolution. Hopefully, the internals won't change as much as to require learning it completely from scratch.

Jun 17, 2010

Regarding your assertion that setting up a vhost is "...unnecessary as you can run multiple Zend Framework projects from different directories on the same (default) document root," this is, and has been, an explicit decision we've made since the very beginning. While it is possible to do as you mention, and it may be the simpler way to do so, the fact of the matter is that we don't do so as a matter of good programming practices. Dropping the entire application into your document root is a recipe for disaster – there are countless anecdotes across the web showing cases where PHP source code in the document root has been served as plain text and/or exploited. By pushing it out of the document root, we provide a more secure methodology from the outset.

Jun 04, 2010

On the contrary, I must say documentation is quite poor generally. Even if you take a look to the API docs, most of the parameters aren't properly explained; or you never know if you need to pass a string, an array or what until you examine the corresponding piece of code and even then it's often difficult to know what to do...

Jun 08, 2010

I don't think removing the use of php's magic functions would add to readability in all cases. Especially in view scripts, which are sometimes written by non-technicals, we should focus on keeping the code as simple as possible.

ZF had been accused of being "java-ish" in the past, why add additional complexity (if only at first glance)?

Jun 17, 2010

Using __call() has a number of disadvantages from the outset:

For newcomers to the framework, I have seen many questions asking, "where did this method come from?" While you argue it's more readable to use __call(), for these developers, they do not know where to find the documentation for those "methods" in the API.

__call() also has performance implications. In this case, you first get trapped by __call(), then it needs to locate a helper class, instantiate it, and then use call_user_func_array(). __call() by itself is roughly 6x slower than a normal function call; call_user_func_array() is quite expensive as well. By using an explicit broker, we can actually eliminate the most expensive parts of the code entirely.

Re-usability suffers. Many developers want to use alternate rendering engines, but still like the view helpers that currently exist. However, since the broker mechanism is built into Zend_View, they either have to copy/paste that functionality, build their own, or omit it. Using an explicit broker makes that functionality more re-usable.

I agree that we shouldn't remove magic functions in all cases – but we need to make analysis like I've done above to see what issues using them causes.

Jun 08, 2010
<ac:macro ac:name="unmigrated-wiki-markup"><ac:plain-text-body><![CDATA[As Carlos mentions it can be difficult to know what available values $options may take without looking more closely at the code - this especially true when working with the Zend_Form.
Change is sometimes hard to adjust to, but I hope that the magic calls are not completely removed. Doing so will make the user code more dense. The lighter the code syntax the better it is to work with.
One problem I've had with the IDE's and code completion is that this doesn't work when using a factory type method is used whether it be the magic method __call or a broker method. So for me the alternative was to create hard methods for the common usages - this I think would be beneficial for some of the more frequent helper/broker controller/view methods and as measure of optimization.
One trick I've seen for minimizing the cost of call_user_func_array is to count the number of args and have explicit calls supporting up to three args, eg.
if ($count == 1) {
} else if ($count == 2) {
$obj->$method($arg[0], $arg[1]);
Something that I've yet to see is a decent way to handle view variable assignments from within the controllers. There are times when a view/script may need more variables than what the controller only needs to work with yet before rendering the script it must also assign a bunch of others - this makes it either ugly or confusing as to how best to then render the view script and either further confusing when also assigning layout view variables - helpers doesn't quite seem the best way of resolving this in all cases. It might be good if some kind of pre-render method was called?
With the right optimizations and I think ZF can perform within reasonable bounds, hopefully the changes planned will not completely lose some of the beauty of the ZF code literally for the sake of performance - a balance and or at alternative could be made, e.g those who know and are overly concerned would create real methods as appropriate as opposed to the _call/get/_set function etc.]]></ac:plain-text-body></ac:macro>
Jun 17, 2010

Regarding the "count" trick you mention, I've seen it myself. It works fairly well, so long as you know the method you will call already. If the method is unknown, then in PHP 5.3, it's basically just as fast, if not faster, to simply use call_user_func_array().

Regarding your points about IDEs, it's one more rationale for using a broker system, as you get code completion in IDEs and editors that support it; it also eliminates the __call()/call_user_func_array() bottlenecks:

<ac:macro ac:name="code"><ac:plain-text-body><![CDATA[
echo $broker->get('helper')->someMethod($arg1, $arg2);

This doesn't completely solve the code-assist problem – you still have short names – but you're now no longer using __call() or call_user_func_array(), which are the largest bottlenecks in terms of performance. It's also more explicit – you're calling methods on your helper objects themselves. The syntax is less compact, but there are ways around that: assigning helpers to the view or to variables inside the view achieve this.

Jun 10, 2010

The obsession with testability at the expense of simplicity and consistency is frustrating. Usually helpers don't maintain state and are an ideal case for static methods. To call a method like this is insanity:

 $view->broker()->execute('message', 'world');

when there is a standard simple equivalent:

 Message::world();

Jun 11, 2010

The obsession with simplicity is frustrating. Usually helpers maintain state across mutiple calls and are not an ideal case for static methods. The call a method like this is insanity:

Because now I can't even mock out it's existence and have to resort to kludgy static invokation overriding in PHP 5.3...ugh. Especially when there is a simpler way I can properly test with:

$view->broker()->execute('message', 'world');

Off the sarcasm trip, it can be frustrating in both directions <ac:emoticon ac:name="wink" />.

Jun 11, 2010

So is this a framework for a fringe group of unit testers? If so, then let's be honest about that. Starting with removing the words "Extreme Simplicity & Productivity" from the ZF overview page.

Jun 12, 2010

Unit testing is one of the more essential requirements in professional development today. It's not a "fringe" practice at all and I am clueless as to where you got that idea. So whether you agree with it or not, the framework allows for testable code. Statics will be used where necessary, but will NOT become commonly required within the framework.

Jun 14, 2010

Undeniably, most web applications aren't unit tested. So yes, fringe is an accurate statement.

Regardless, sacrificing good software design, the most important characteristic of which is simplicity, to appease unit testers is madness. These complexities don't mesh with the MIT or "Worse is better" sensible approahes to design. I won't convince you of this, but this framework has a reputation that won't improve until the academics stop their fiddling.

Jun 17, 2010

Sure, let's drop unit testing from Zend Framework. And in six months, I'll ask you again if you think it's a fringe requirement. At that time, we can remove the "& Productivity" from the overview, because without a tested codebase, we won't be able to maintain it, and you won't be able to be productive with it anymore due to the bugs.

Look, we're not asking you, an end-user, to unit test your application. However, you, as an end-user, are asking us to give you quality code that you can depend on. The only way we can do that is to test it, and writing code that is testable in the first place makes this job easier for ourselves, as well as the other dozens of developers that may assist us.

We also have a responsibility to end users: they should be able to test their code easily, as well as be able to inject their own dependencies at will. Statics are a poor solution for this. I can't tell you how many times I thought statics were the right solution... only to end up with a ton of code duplication and hacks when I wanted to extend or re-use them.

Regarding your later post, you make the assertion that testable code "sacrifices" good software design. I'd argue the opposite. Writing testable code often helps expose bad APIs. Additionally, when doing test driven development, you give yourself a chance to play with the API before coding it, giving yourself a chance to ask whether it's one you'd actually want to use. I did this with the rewrite of Zend\Session, and I scratched my initial designs as they were too complex to use; the final version ended up fairly simple for use... and also testable.

You may consider unit testing fringe. I, and many others, consider it essential for ensuring code quality. You're welcome to disagree.

Jul 27, 2010

It's also about good practice. If you add static operations, it's too easy to call those operations from places where you shouldn't. With a non-static interface, you have control over access to the procedure in the layers between. Especially in a project with multiple developers, this is a must. You might not like someone calling a view helper in your business object, for example. Yes, he could construct the helper, assuming there are no initialization dependencies. Say a view helper that renders a sitemap, gets the site tree injected. If the helper procedure is static, that dependency is as well. Long story short, you're making abuse very easy. The difference to functions and globals is marginal. You know, the olden, procedural days. When everything PHP was complete and utter crap, even if we didn't know it. <ac:emoticon ac:name="wink" />

Jul 04, 2010

With all due respect, I'd point out this issue http://zendframework.com/issues/browse/ZF-5734 which, besides being wrong on its own, makes almost impossible to create some rational application structures.

Jul 04, 2010

Please see my comments on that issue. Basically, it's not "wrong" – there were reasons we did not implement such functionality, and won't be doing so anytime soon. However, by having strong (and hopefully simple) interfaces, we can make it possible for userland implementations that have those requirements.

Jul 05, 2010

I see, thanks for your comment to which I replied there. Maybe we should discuss it here, shouldn't we?

Sep 27, 2010

No, it should be discussed when we start creating proposals for the MVC milestone. <ac:emoticon ac:name="smile" />

Oct 03, 2010

Just came across a beautifully done presentation on another frameworks large update. Something like this http://rubyonrails.org/screencasts/rails3/getting-started-action-dispatch would help out a lot with the launch of 2.0.

Nov 20, 2010

What frustrates me is:

1) The morass of file paths and file hunting to load them which I suspect is expensive.

2) "Use at will" seems to be degrading where "instanceof" tests on an abstract instead of an interface

3) Zend_Application seems to have added another layer of load (should be lazy instantiation - always)

4) The MVC isn't fast enough to provide image serving (a lot more requests). I think it should be.

5) Remove all regular expressions unless really needed, because they're expensive too.

Make the cache the first resource to get, so even the config itself is cached unwrapped as an array. Cut right down on checking for files/modules everywhere. Test for files once then record it all in memory cache and don't test again.

The whole front-end needs to be super fast. Do not load anything until it is required. Cut out as much plugin/helper searching as possible. I ditched the dir layout and made it a dir of App, MyLib, Zend, where App looks like a library itself except for the non-class files it contains so most classes come straight off the include path. If people need to load stuff outside if this convention then I think it should be a hook to custom load before failure.

Ditch the no-module dir layout entirely. Make modules discrete units declaring dependent modules.

I have rolled my own-front end to do these things and it is very fast, but admittedly my hack and I'm suffering because it exposes how much use-at-will in the Zend library seems to have degraded.

Nov 20, 2010

I appreciate your frustration. I invite you to look at what is happening currently in the ZF2 repository, as we're addressing much of what you discuss in this comment already.

1) Not completely sure what you mean by "morass of file paths", but I suspect this may have to do with two separate issues: (a) application resources do not follow the same rules as library autoloading, leading to many stat calls, and (b) plugin loading uses many stat calls. (b) is already addressed in the ZF2 master branch. (a) will be resolved as we work on the MVC milestone.

2) One of the driving goals of ZF2 is to have strong interfaces, and only typehint on interfaces.

3) Zend_Application's primary performance issue is due to plugin loading - something already solved in ZF2 master. That said, it has additional issues – no clear way to load resources only as needed by a specific request, no caching of configuration (as you note later), etc. Those are all items we're looking at in the MVC milestone.

4) I agree on this point. The goal of the ZF2 MVC will be to return a response as quickly as possible, and mechanisms for returning that response as soon as it is ready.

5) Give me benchmarks showing regular expressions are slow. Hint: you can't. Modern versions of the PCRE library are blazing fast, and our own profiling has shown that regexp are the least of our worries with regards to performance. A well-formed regex can perform much faster than a series of string-related functions.

While I understand your request about ditching the "no-module" directory layout, I'll note that the include_path is the wrong reason to do so. Autoloading based on the include_path is simply bad from a performance perspective (something I've blogged on as part of my research for alternate autoloading solutions for ZF2). There are better reasons to do so: consistency between application and library code, consistency. That said, we also want to make the migration path for ZF1 users as easy as possible, so we'll likely need to ensure current application structures continue to work.

Over all, however, I think you'll find that most performance concerns have been addressed in the current ZF2 master branch. Some work still needs to be done – Zend_Form still needs to be refactored to use the new plugin broker mechanisms – but the improvements are quite dramatic already.

Nov 21, 2010

Regarding Mark's comment of ditching the no-module directory layout, I think I can agree. While I understand migration issues are a concern for some, isn't ZF2 a backward compatibility break? If a more flexible, modular application structure is to be desired, supporting the standard application structure of ZF1 will add additional complexity to MVC code.

As flexibility is concerned, one can look at Magento's modular architecture. I've been developing with Magento for the past few months, and while it is notorious for code smells, it has a fairly flexible modular layout. For ZF2, I think most of us would like to see modules be first-class citizens. Rather than have an application namespace starting with the application directory, and plural directories (forms, resources, controllers, plugins, models, etc...), why not have source folders and namespaces? For example, to achieve flexibility that would trump Magento, we could have a directory structure like the following:

apllication/configs/application.ini

apllication/src/<namespace>/<module>/Controller/Index.php

apllication/src/<namespace>/<module>/Model/<model classes>

apllication/src/<namespace>/<module>/<other module sub-categories>

My idea for namespaced modules is inspired by Magento. With the above structure, we could have a default application namespace and module defined in application.ini. Additionally, adding the ability to "rewrite" or overload an existing module's class. For example, lets imagine I have an application whose default namespace and module are as follows:

The base module of the Application namespace contains the typical sub categories, such as Model, Controller, etc... If I want my application to be extensible, like Magento, implementing developers should be able to override/extend the Base module classes as needed. So let's say I'm a developer and want to extend an existing Base module controller. I would add my own namespace and module:

In application.ini (or better yet, a module specific config file), a controller rewrite configuration will need to be specified. So something like

resource.frontController.rewrite.Application.Base.Controller.Index = "\Joly\Base\Controller\Index"

Or perhaps a better place to specify rewrites would be in a single rewrite node specifying all classes being overridden:

rewrite.Application.Base.Controller.Index = "\Joly\Base\Controller\Index"

When the autoloaders are initialized, the "Joly" namespaced class would replace the "Application" class.

I have an open source CMS I will be working on soon and need it to be a very flexible, modular application, and the current MVC isn't of much use to me. The notes regarding the MVC milestone are encouraging, as the issue regarding modules being "tacked on" is clearly stated. On a side note, I have not noticed any proposals for the ZF 2 MVC components yet. I could put together a proposal for this myself if there aren't any proposals currently in the works.

Nov 23, 2010

Matthew. Replying to the 5 points earlier. I've seen your blog article now and looked at the ZF2 snapshot now too - thanks.

1) Yes, stat calls and file searching/testing. Also, I had no idea that the include path is sub-optimal. File loading performance solved with ZF2 then hopefully.

My use of "morass" was more about the apparent complexity and variants in the manual on dir layouts and then also what the library code itself defaulted to. I just find myself spending time trying to work out where a file goes in order to get it picked up by default and when that fails end up wrestling with the loader configs.

The manual recommends this:
http://framework.zend.com/manual/en/project-structure.project.html

but then we see this:
http://framework.zend.com/manual/en/zend.controller.modular.html

If the manual gave full path examples based on one, and only one dir layout and ZF had corresponding defaults for all locations I think ZF would feel a lot quicker to work with. Perhaps longer term the new tooling will become the way to grow every aspect of the app, with a verbose option so you can see where all the files have been created.

2) Interfaces. Could there be a hard rule that between-component object communication must be by interface? So reducing this list somewhat: grep -r Abstract library | grep instanceof | less

3) I get the impression that ease of migration is a strong consideration despite the BC break opportunity, so perhaps we're stuck with Zend_Application. In my MVC I just did away with it and provided resource loading in the front controller assisted by resource bootstraps to call hasResource/getResource again for dependencies. All cached, lazy loaded, just a few methods to do it. Zend_Application seems like bloat to me.

4) Encouraging. I suppose in production I can at least concatenate the classes required in every request into a single file if need be.

5) Regular expressions. Years ago I won a sporting bet with a colleague over this and that formed my view. You say it's been optimised. I'll take your word for it and agree it's nothing compared to disk or db access time costs. Not worth trifling over.

Nov 23, 2010

Responding to the individual points...

1) This is a case where some docs have gone out of date without being updated. The zend.controller.modular docs are out-of-date, and should likely be removed or revised at this time. The project-structure docs are current, and reflect how Zend_Tool will create a project.

2) Using interfaces does not necessarily mean eliminating instanceof checks. It's often most flexible to allow passing either an object or a class name representing an object. This leads to instanceof checks in the code body, as we have to then eliminate the type hinting in the method signature. What's more important is that we program to the interfaces, and don't call methods defined in the concrete classes that are not part of those interfaces.

3) One thing we're looking at with Zend\Application in 2.0 is having the container extend PluginSpecBroker, and then no longer bootstrapping all resources. This allows the application to pull resources as needed – and only when pulled would they be instantiated. This will answer many performance issues, particularly in cases where you are only using a few resources out of your configuration.

4) Absolutely. However, with a good opcode cache, class-map based autoloading will eliminate the need to do so, as they'll be cached in-memory after the first request.

5) That was years ago. <ac:emoticon ac:name="smile" /> PCRE is incredibly fast, particularly when you're not doing crazy things like negative look-ahead/behind (and there are very few, if any places we do that in ZF). While most PHP string operations are faster, you often need to string together (pardon the pun) several such operations to achieve what you can do in a single regex – negating the performance benefit.

Glad to see that current development is answering some of your questions already, and I look forward to your input when we open up the MVC milestone.

Nov 23, 2010

To the genearl goal "ease the learning curve":

Many people write here, that writing more/better documentation, and more publishing of articles, slideshares and so on would improve the situation.

Sure, but is this the "main" goal?

In my oppinion this is somehow the wrong approach!

If the APIs of the components get consistent, many questions for ZF users are just eliminated with that. The classes are a big part of the "documentation", if they are clear, then you don't have to read a extra documentation in many cases.

Sure you still need a good documentation, slideshares and so on, but even this would become easier.

Nov 24, 2010

During the "Introducing ZF 2.0" presentation I gave at ZendCon with Ralph, the "ease the learning curve" idea was a common thread throughout. As you note, it's not just documentation, but also making the code more consistent and simpler. (In fact, I actually specifically called out that the first step to easing the learning curve is code-based.) That said, the documentation also must be made more consistent, and more comprehensive, to ensure that those consistent APIs are readily apparent, as well as all their options and behaviors.

Dec 02, 2010

In the new ZF2 Loader component I notice mixed use of the leading underscore in private/protected declarations. Is this some emerging change in the coding standard?

More generally, is the coding standard in ZF2 decided yet? Can I look it up?

Dec 03, 2010

We decided via online polls some months ago to:

Remove the requirement for leading underscores on non-public members for new code

Make a low-level, late milestone for removing underscores prior to the first beta

We can't automate this completely as there are a number of places in the framework where we have underscore-prefixed methods where removal will now cause conflicts with existing methods.

I plan to publish a revised ZF2 coding standard on the wiki in the coming weeks to reflect this and other changes we've made (typically on the zf-contributors list).

Dec 10, 2010

What drove the decision to remove underscores from private/protected methods and variables? Is there any logic behind this decision, or was it solely based on the results of online polls? In my personal dealings with Zend Framework, which I use consistently for most projects, I have found the underscores to be invaluable with regard to readability, and differentiation.

Dec 10, 2010

There was a ton of discussion on the topic on the zf-contributors list earlier this year, following which I opened a poll to the general public. The majority was in favor of removing them.

While I could argue either side of the decision, the salient points are:

In most the vast majority of class properties, we simply don't use "public" anyways – which means the underscore is largely irrelevant for them.

Methods are the one place where having the leading underscore can help in differentiating method visibility during use. That said, API documentation and IDE hints (and yes, you can get reasonable hinting in text editors such as vim via a number of plugins) largely obviate the need for such differentiation.

Changing visibility to public requires not just changing the visibility, but also removing the underscore, and removing it in all calling code. This is a poor situation at best, and one that completely goes away by dropping the underscore.

After having written a number of components without the leading underscore at this point, I have to admit I favor its removal at this time, as it streamlines and simplifies the coding process, particularly when under rapid iterations.

Feb 02, 2011

Is dependency injection going to still require some kind of bootstrap file for every resource?

If a unified constructor is not popular (re: comments on superceded ZF2 roadmap page), could it be ruled that ALL constructor arguments in ZF2 must be defaulted (null if necessary) to make them technically optional? So allowing instantiation as "new ResourceClass()" by default by the DI?

If ZF2 got rid of all statically accessed singletons except one main singleton - a central app/kernel object (registries for all singletons, all App config, etc.), constructors could grab the kernel statically and interrogate it to work out dependent dynamic defaults. Or worst case, just instantiate in an initially unworkable state, pending an init()? This way you still have the constructor's type hinting showing what the object will need to work - so hopefully solving objections that the original unified constructor provoked.

This allows the DI to just call "new ResourceClass()" and then if it also has some config to pass to it, follow up by then calling setOptions($config) on it, perhaps with a check on method_exists(), which on failure, throws a "No setOptions() method available. Configure by resource bootstrap instead" exception?

If this, as a framework-wide rule was tolerable (and a script could easily ensure it was being observed), I'd have thought it would help automate config of non-resources too like auto-configuring complex forms and so on.

Feb 23, 2011

Any chance of moving from "getProperty()" naming to "property()" naming for getters?

The getters are called most often and I think needlessly clutter code with "get" prefixed everywhere. property() seems adequate to me and clearly asking for a value. Not suggesting any change to setters (setProperty()).

In my own code I've created a Scaffold abstract class to magically provide for setter/getters as above with legacy support for getProperty() style calls. So now I just declare private properties in a class extending Scaffold, all of which are magic-call-accessible until I'm ready to fill out explicit setProperty()/property() methods.

Feb 23, 2011

if we have set*() methods, I think it's just as clear to also have their get*() counterparts.

Also, by prefixing it's automatically clear what a method does...

Feb 23, 2011

I don't understand your point of view. The getters are prefix often by get <ac:emoticon ac:name="smile" />

And, the convention in ZF is :

For object-oriented programming, accessors for instance or static variables should always be prefixed with "get" or "set".

Feb 23, 2011

Yes that is the convention.

Sorry, I think I'd only be repeating my earlier post, other than to add that I just thought some other frameworks like Alloy look more readable without "get". First page of google results for "getters setters" influenced me too. Anyway, no biggy - it was just a thought.

May 16, 2011

If you don't know who you are, then you don't REALLY know where you're going, since you might then just be the guy over there walking the other way. But seriously.. <ac:emoticon ac:name="smile" />

What you're lacking here is a mission statement (or really.. a short identity tagline under the logo) that more definitively establishes what Zend Framework 2.0 is 'all about' in the PHP development ecosystem.. and, just as importantly, who the target developer (market) is.

This is more pragmatic than it might initially sound as it can set reinforcing context and expectation for the kind of design decisions that have been, and are now, being made for v2.0.

Since the PHP Developer community is vast and there's incredibly wide variance in developer skill, knowledge, and experience, it might be beneficial now to the ZF product brand (and focus!) to 'claim a little higher developer ground' amid the myriad PHP frameworks out there:

Zend Framework: Community-driven, enterprise-grade PHP Development Stack (or 'Web Library'.. or whatever)

Given this, or something like this (I presume.. with something similar to the 'enterprise-grade' reference), it would then mean ZF 2.0's core mission is NOT really about 'Simplicity' nor catering to less experienced PHP developers or those less corporate-focused in their practices, code, and methodologies.

I think this is actually the truth, but no one's really saying it (and there's definitely not a 1-line product 'mission' on THIS important page).. so you end up getting into mini 'Unit Testing' debates like the one in comments above)

.. but with a SHORT EXPLICIT identity tagline/product motto including (I assume again.: an 'enterprise','corporate', or 'industrial' reference):

*Unit-Testing? ... IN!

*Dependency Injection? . ABSOLUTELY!

*Doctrine 2 ORM support? .. MAKES SENSE!

*Community voting on core components & design? . NOT NECESSARILY, BUCKO!

*Follows BEST PRACTICES and STANDARD CONVENTIONS (when at all reasonable)? WELL, OF COURSE..it's the 'Enterprise-grade' framework!

Just another 2 cents.

Nov 30, 2012

"Simply stated, Zend Framework 2.0 MUST be an exemplar of PHP 5.3 usage."

The framework - specifically the EventManager - uses Traits that are supported from PHP version 5.4.0, according to the PHP docs (http://php.net/manual/en/language.oop5.traits.php). How is that handled? Or is the PHP documentation in error?


text:
Boy's Camouflage Clothing
Having a baby boy? The Camo Shop carries overalls, pants, hats, baby gift set outfits all available in the Realtree camo pattern. Our kids camouflage clothing are great for baby showers or everyday use.
Browning Baby Tan Camo Gift Set$24.95
Out of stock
Child Camo Short Sleeve Tee Shirt
Regular Price: $14.95
Now only: $9.95
Kids Camo Fleece Sweatshirt$14.95
Out of stock


text:
High-cut profile for increased ankle support, stability and protection
Material bridge connects tongue to the upper eliminating debris from entering the shoe.
Provides rearfoot stability and protection.
The right solution for the toe protection in mountain and trail environments
An abrasion resistant lining that allows for excellent breathability and quick drying.
GORE-TEX® Performance Comfort Footwear keeps your feet dry -from the outside as well as from the inside.
Delivering optimal traction on varied surfaces, Salomon's Contagrip® outsoles use the ideal combination of specialized rubbers for each specific use
Salomon's low profile advanced chassis, placed between the outsole and midsole, maximizes security, motion control, energy management and push through protection for a high performance, stable and responsive ride.
Molded EVA midsole provides lighweight cushioning and stability
OrthoLite® sockliner combines a specific Ortholite® foam and an EVA heel cup. Ortholite® foam creates a cooler, drier, healthier, better cushioned environment under the foot. It will not break down or lose effectiveness over time. Recycled tire content to protect the environment. EVA heel cups allows for a better heel support and added cushioning.


text:
8/24 in Yankee History
2002: At the Stadium, Rangers' starter Aaron Myette's first-inning, bases-loaded walk to Jorge Posada scores Jason Giambi and ties the game at 1-1, after Alex Rodriguez had homered off Roger Clemens. Six innings later Giambi's long home run to right off lefty Juan Alvarez is the difference in a 3-2 Yankee win.
1983: Brett Gardner is born. Happy 27th to Speedy Gardzales!
1977: Catfish Hunter notches his final win of the year' an 11-1 four-hit victory over the Twins. New York support Hunter with homers by Roy White, Mickey Rivers, Chris Chambliss and Bucky Dent.
1968: Mel Stottlemyre and the Yankees top Denny McLain, 2-1, for one of only 6 losses (against 31 wins) that the Tiger ace will suffer this year.
1960: Despite Roy Sievers' 2 homers and a double' the Yankees beat the White Sox 3-2' dropping Chicago 1 1/2 games off the pace and into a second place tie with the Orioles. Art Ditmar is the winner over Herb Score.
1951: Against Cleveland's Early Wynn, Gene Woodling cracks his third homer off the Tribe ace this year' as the Yanks win 2-0. Woodling went deep on Wynn on June 24th' July 24th and today. Mickey Mantle makes his first appearance since his recall from the minors.
1904: The Highlanders' Wee Willie Keller collects 2 inside-the-park homers against the St. Louis Browns in a 9-1 win at Hilltop Park.


text:
ERROR CORRECTION: TravelCenters Of America LLC Fourth Quarter Conference Call Scheduled For Wednesday, March 13th
TravelCenters of America LLC (NYSE MKT: TA) today announced that its fourth quarter and year end 2012 earnings release and conference call will be on Wednesday, March 13, 2013. The previously announced conference call date of Wednesday, February 27, 2013 was announced in error yesterday.
On the morning of March 13 th, TA plans to issue a press release containing its fourth quarter and year end 2012 financial results before the NYSE MKT opens for trading. Later that day, at 10:00 a.m. Eastern Time, TA management plans to host a conference call to review the fourth quarter and year end results and to take questions.
The conference call telephone number is (800) 553‐0288. Participants calling from outside the United States and Canada should dial (612) 332‐0530. No pass code is necessary to access the call from either number. Participants should dial in about 15 minutes prior to the scheduled start of the call. A replay of the conference call will be available until 11:59 p.m. Eastern Time on Wednesday, March 20, 2013. To hear the replay, dial (320) 365-3844. The replay pass code is 279904.
A live audio webcast of the conference call will also be available in a listen-only mode on the company's web site, which is located at www.ta-petro.com. Participants who want to access the webcast should visit the company's web site about five minutes before the call. The archived webcast will be available for replay on the company's web site for about one week after the call.TA's travel centers operate under the "TravelCenters of America", "TA" and "Petro" brand names and offer diesel and gasoline fuel, restaurants, truck repair services, travel and convenience stores and other services. TA's nationwide business includes travel centers located in 41 U.S. states and in Canada.
Select the service that is right for you!COMPARE ALL SERVICES
Action Alerts PLUSTry it NOW
Jim Cramer and Stephanie Link actively manage a real portfolio and reveal their money management tactics while giving advanced notice before every trade.
Product Features:
- $2.5+ million portfolio
- Large-cap and dividend focus
- Intraday trade alerts from Cramer
- Weekly roundups
TheStreet Quant RatingsTry it NOW
Only $49.95/yr
Access the tool that DOMINATES the Russell 2000 and the S&P 500.
Product Features:
- Buy, hold, or sell recommendations for over 4,300 stocks
- Unlimited research reports on your favorite stocks
- A custom stock screener
- Upgrade/downgrade alerts
Stocks Under $10Try it NOW
David Peltier, uncovers low dollar stocks with extraordinary upside potential that are flying under Wall Street's radar.
Product Features:
- Model portfolio
- Stocks trading below $10
- Intraday trade alerts
- Weekly roundups
Dividend Stock AdvisorTry it NOW
Jim Cramer's protege, David Peltier, identifies the best of breed dividend stocks that will pay a reliable AND significant income stream.
Product Features:
- Diversified model portfolio of dividend stocks
- Alerts when market news affect the portfolio
- Bi-weekly updates with exact steps to take - BUY, HOLD, SELL
Real Money ProTry it NOW
All of Real Money, plus 15 more of Wall Street's sharpest minds delivering actionable trading ideas, a comprehensive look at the market, and fundamental and technical analysis.
Product Features:
- Real Money + Doug Kass Plus 15 more Wall Street Pros
- Intraday commentary & news
- Ultra-actionable trading ideas
Options ProfitsTry it NOW
Our options trading pros provide daily market commentary and over 100 monthly option trading ideas and strategies to help you become a well-seasoned trader.
Product Features:
- 100+ monthly options trading ideas
- Actionable options commentary & news
- Real-time trading community
- Options TV


text:
Swedish friends Viktor Tell and Mikael Söderlind founded Happy Socks on a dreary spring day in 2008. Their intention was to bring color and cheer to the world with a basic and often overlooked piece of clothing. Happy Socks' vibrant designs are created by a team in Stockholm, while the high-quality cotton product is made in a family-owned Turkish factory.
Sign Up and Enjoy 20% Off.


text:
London may have an abbreviated Fashion Week, but the city more than makes up for it in terms of wow-worthy looks. And we're not just talking about the sartorial high notes on the S/S 14 runways! The front-row attendees served up an inspiring display of ensembles at all the biggest shows and soirees, and we're delighted to share all of the outfit details with you today.
What The Stylish Set Wore To London Fashion Week
- 1 of 15
Click through to see our favorite #LFW looks, and don't forget to visit our hub for even more Fashion Month news.
- 2 of 15
WHO: Rosie Huntington-Whiteley
WHAT: At the ELLE magazine drinks reception to celebrate London Fashion Week.
WEAR: Stella McCartney jumpsuit.
- 3 of 15
WHO: Kelly Osbourne
WHAT: Arriving at the House of Holland S/S 14 show.
WEAR: House of Holland dress.
- 4 of 15
WHO: Zoe Kravitz
WHAT: Hanging at the Longchamp flagship store opening.
WEAR: Alexander Wang top; Chanel pants; Longchamp bag; Chanel shoes.
- 5 of 15
WHO: Alexa Chung
WHAT: Celebrating the opening of Lonchamp's European flagship store.
WEAR: Isabel Marant sweater; Jonathan Saunders Jemima Fitted Vinyl Dress ($1208); Dolce & Gabbana shoes.
- 6 of 15
WHO: Cara Delevingne
WHAT: Hanging out at a W magazine party held at The London Edition Hotel.
WEAR: Saint Laurent suit, blouse, and pumps.
- 7 of 15
WHO: Olivia Palermo
WHAT: Spotted front row at the Emilia Wickstead S/S 14 show.
WEAR: Ray-Ban sunglasses; Tibi sandals.
- 8 of 15
WHO: Jourdan Dunn
WHAT: Spotted at the Topshop S/S 14 show.
WEAR: Givenchy Doberman and Photo Print Tartan Sweatshirt ($1170).
- 9 of 15
WHO: Georgia May Jagger
WHAT: Feting Lonchamp's first European flagship store.
WEAR: Longchamp bag.
- 10 of 15
WHO: Arizona Muse
WHAT: At the Tom Ford London flagship store opening.
WEAR: Matthew Williamson dress.
- 11 of 15
WHO: Harley Viera Newton, Poppy Delevingne, Daisy Lowe, Caroline Sieber
WHAT: Front row at the Erdem S/S 14 show.
WEAR: On Harley: Illesteva sunglasses; Christopher Kane dress; Dior bag; Versace shoes. On Poppy: Dsquared sunglasses; Erdem dress; Paule Ka shoes. On Daisy: Erdem dress. On Caroline: Celine top and trousers; Louis Vuitton bag and shoes.
- 12 of 15
WHO: Miroslava Duma
WHAT: Outside the Burberry Prorsum S/S 14 show.
WEAR: Burberry Prorsum jacket, skirt, and shoes.
- 13 of 15
WHO: Pixie Geldof
WHAT: At the Longchamp European flagship store opening.
WEAR: Antipodium coat; Topshop jeans; Louis Vuitton bag; Erdem shoes.
- 14 of 15
WHO: Sienna Miller
WHAT: Photographed before the Burberry Prorsum S/S 14 show.
WEAR: Burberry Prorsum jacket, skirt, and clutch; Roland Mouret shoes.
- 15 of 15
WHO: Kate Moss
WHAT: Photographed at the Topshop S/S 14 show.
WEAR: Kate Moss for Longchamp clutch; Alaia boots.
Doberman and Photo Print Tartan SweatshirtGivenchy, $1170
Jemima Fitted Vinyl DressJonathan Saunders, $1208


text:
Socks by Sock Dreams
We offer FREE USPS shipping on all US orders!
Browse By
- Argyle
- Artistic
- Baby & Kids
- Bamboo
- Bootsocks
- Cable Knit
- Cashmere
- Compression Socks
- Cotton
- Critter Socks
- Cronert
- Cuban Heel
- Dahlgren
- DreaM Stockings
- Dreamer Socks
- Eco Friendly
- EG Smith
- Fishnet
- Floral
- Geeky & Nerdy
- Gumball Poodle
- Hand Made and Altered
- Indulgences
- Lace
- Larger Feet
- Lightweight
- Made in the USA
- Men's Socks
- Niqkita's Stash
- Non-Constrictive
- Novelty Socks
- Openwork
- Plus Sized
- Polka Dots
- Polonova
- Rainbows
- Ribbed
- RocknSocks
- Scrunchy Socks
- Sheer To Waist
- Silk
- Slipper Socks
- Small Feet
- Sock It To Me
- Solid
- Sport Socks
- Stripes
- Sweet Marcel
- Tabbisocks
- Tabi
- Terry
- Tie Dyed
- Trouser Socks
- Tube Style
- Vices
- Victoriana
- Warm!
- Wool
- Woven Toe Seam
Sheer Dot Tights
Super fun and super sheer tights with opaque polka dots.
Label says these fit 5'-5'8", 90-148 lbs and we agree.
Our stretch tests showed that although the hips and waist stretch to 39 inches, they'll rider lower as they do. Maximum stretch in the thigh of 23 inches, with a 30 inch inseam means that these are not the tights for folks with long and curvier legs.
Solid panty area, with gusset. The polka dot pattern goes all the way to the toes of the tube-style foot that should fit most feet.
Additional Info: *We have a limited amount of the White for now, but our toes are crossed that it'll be back in the Spring!
Made in Japan.
PLEASE NOTE: Please be aware that leggings, tights, and other products considered intimate wear are non-returnable once removed from their original packaging.
Fiber Content: 90% nylon, 10% spandex
Hand wash cold, line dry.
Label: Tabbisocks
I have ordered from you guys twice now. Everything has come quickly (and for FREE!) and I have loved everything I ordered. I love the variety you have on the site and I love that you have so many plus size options!
~ Maureen K.