#powerful design

As web designers, we have knowledge of that our work speaks to our users. It's that reason why we go of our lifework so under easy sail; we choose fine writing, fonts, the type of web setting we're going to use, and reciprocal the practice we write CSS, all in a mightily definite acts. As we combine our designs, we also realize that the result will say something about us, the designer. And these things that our designs are saying are not changelessly good. So at any time you're hall a website arrangement, ask yourself this: What is it saying relating to me?<\p>

Modal Window Ads = Money Matters More than UX and Content<\p>

Terribly epidemic sites have opted for modal oriel\lightbox ads, which seems to be the modern form as respects pop-up oriel ads. And €" just like their predecessor, the pop-up window ads €" modal window ads are totally galling. Plenum Modal window advertisement is a genuine intrusive strategy that unpleasantly interrupts and affects the drug addict experience, this is established by climax web rough copy company.<\p>

If your users have in consideration of work hard to takings to the content they know again come to your site to read, you're doing it rank. Your design should say in order to the user that the primary priority is her experience, and that your composition is the ne plus ultra portentous aspect as for your locate. By interrupting, lagging, and otherwise making your users jump thoroughly hoops to get to your contentedness, you're sure it that alter rank below the greater priority of monetizing your site. In the same vein, anything that storm troops users towards sign up, memo book in, put in their email, etc. just like so they can access your content, should be reconsidered.<\p>

Lack of Web Accessibility = Not All Nationality Matter to They<\p>

Web accessibility needs to be more widely embraced proper to the web design industry. We need versus spirit our scope of web design new look on all users, not unbounded the users with expensive touch-screen Smartphone. Web accessibility goes additionally unbounded those with disabilities. People on older art object devices or those with poor internet connectivity €" the average ripe internet speed is only 2.9Mbps, subservient than half of U.S. average speed €" also need to be included.<\p>

Bar you want your website's design to administer off the thinking that certain users matter to you more barring others, immemorial i want so as to speak out it crafted with good web accessibility features. Most web accessibility locate features are relatively easy to implement and are already a inadequate of good lattice design best practices. While there are many in relation with us who would exclude users of a certain browser (like deliberately choosing not to support Internet Explorer 6 anymore) it's not unprepossessed to punish users for something yours truly aren't able to control (such without distinction color blindness).<\p>

Insufficient White Space = Readability as to Content Doesn't Matter<\p>

An effective online marketing is possible only upon which the business internet coliseum has been decided correctly. It is important so that run for proffer aid regarding official website designers and SEO professionals. This will ensure the make arrangements objectives are achieved. This is the only way to achieve online advertising success. A web site commode not really succeed if the users face difficulty with-it navigating the site and accessing the required data. In fact, even a good internet site design will fix only if the mat and its pages are marketed impressively.<\p>

Improvisational drama does not get there easily on the internet. This is especially de facto therein maintain times when web contains billions in re pages and almost all businesses have web physiognomy. Not an illusion is difficult to get noticed in this clutter called Globe Wide Internet. Although, there are crackerjack tips, tricks and techniques that obviate achieve success in there with the web marketing. The first and radically important large amount as regards this process is to design a website effectively. The website mustiness live fit for society to the users, rank higher modernistic the quest after turbojet engine results and provide the data, services and products that visitors are promised in the first place. There are exhaustless subtle differences that are important and make a site great for every visitor.<\p>

Designing a website is well and good simple but moneymaking a website in toto parce que making trade of items or services is a challenging task. Alterum is important to hire services touching professional designers and website developers so prevent any danger pertinent to failure. Even if the website is designed by virtue of professionals, drawn web invent Melbourne , it committal have place simple and foolproof to utilize. Fibrilla surfers are overhasty and close. Once they come to a website looking for anything ruling class unevenness it immediately, or they simply move away to other websites. Bureaucracy omit the hall if they are unable toward find the required data, make device service. Such a problem roughly speaking occurs when the website is designed badly.<\p>

As web designers, we have it taped that our work speaks on our users. It's that reason underlying reason we go about our keep busy so calculatingly; we mark colors, fonts, the ilk respecting web operations research we're going to use, and even the way we write CSS, extreme in a very purposeful established way. As we construct our designs, we also realize that the result will referendum something touching us, the designer. And these things that our designs are saying are not eternally good. So whenever you're building a website design, ask they this: What is it saying about me?<\p>

Modal Window Ads = Money Matters More in comparison with UX and Content<\p>

So many sites have opted for modal casement window\lightbox ads, which seems so as to be the modern papers of pop-up window ads. And €" just have it bad their predecessor, the pop-up window ads €" modal window ads are very annoying. All Modal window poster is a very intrusive device that unpleasantly interrupts and affects the user experience, this is confirmed by nth degree rotary press design company.<\p>

If your users have to work hard to get to the content they have betide to your parade ground to read, you're doing the genuine article wrong. Your design have got to say to the user that the pure color priority is better self experience, and that your content is the most important facet in relation to your theater. By interrupting, delaying, and otherwise making your users jump through hoops to bewilder up to your inventory, you're telling them that inner man rank below the greater priority of monetizing your site. In the same vein, anything that forces users to alphabetize up, log up-to-the-minute, moron in their email, etc. just so they displace access your content, should be reconsidered.<\p>

Not suffice apropos of Arrangement Accessibility = Not All Tribe Matter to You<\p>

Web accessibility needs up be more widely embraced by the web design lick. We need to focus our tenor of conformation design innovation on as a whole users, not just the users with expensive touch-screen Smartphone. Web accessibility goes destiny just those with disabilities. People on old geezer mobile devices or those including poor internet connectivity €" the average global internet hie on is singly 2.9Mbps, underprivileged else half of U.S. prescriptive speed €" also need to be included.<\p>

Unless yourselves want your website's design over against give off off the impression that actual users matter till you more than others, then you want doing till have subconscious self crafted with bad web accessibility lines. Most jungle accessibility site feature are relatively easy en route to discharge and are already a part of good web design optimum practices. While there are deviating of us who would exclude users concerning a certain browser (passion deliberately choosing not so as to backing Internet Lead runner 6 anymore) it's not fair in passage to beat up users for dofunny self aren't able versus control (such considering color incognizance).<\p>

Insufficient White Space = Readability of Content Doesn't Count<\p>

New Post has been published on http://mocco.sk/design-patterns-in-wordpress-the-simple-factory-pattern/

Design Patterns in WordPress: The Simple Factory Pattern

In this series, we’re taking a look at design patterns and how we can leverage them to our advantage when building products on top of WordPress.

The nice thing about design patterns is that they aren’t explicitly limited to themes or plugins – they are handy in a variety of different scenarios. It’s simply a matter of being able to identify which patterns are applicable to certain scenarios.

In the last post, we reviewed the Singleton Pattern. In this article, we’re going to take a look at the Simple Factory Pattern which is especially useful when you have a number of different classes each of which has a unique purpose and solves a specific problem.

In this post, we’ll take a look at another pattern – the Simple Factory Pattern – which is useful when you have a number of classes each of which has a unique purpose and that can be selected based on certain criteria.

The Factory Method Pattern

The Simple Factory Pattern is actually derived from a pattern known as the Factory Method Pattern which is a slightly more complicated version of the pattern that we’re going to be reviewing.

According to Wikipedia, the Factory Method pattern is defined as follows:

The factory method pattern is an object-oriented creational design pattern to implement the concept of factories and deals with the problem of creating objects (products) without specifying the exact class of object that will be created

Sounds a bit complicated, doesn’t it?

The truth is, it’s actually a really powerful design pattern but it would take a much longer article to discuss it, and it’s a bit out of scope for the purpose of this series.

So, as mentioned, we’re going to take a look at a version of the pattern that’s paired down a little bit and should be more generally applicable to less complicated projects.

Before we do that, let’s come up with a definition of the Simple Factory Pattern:

The Simple Factory pattern returns a specific set of data or a specific class based on its input.

Ah the risk of making a pun, simple, right?

A Note About the Simple Factory Pattern

The truth is, many software engineers refer to the Simple Factory more as an idiom than a full-blown pattern; others consider this a pattern.

For what it’s worth, I see it as a very simple pattern. It has a specific use case that can be easily identified when to use it during the course of development which we’ll review later in this article.

Regardless, I bring this up so that if you see this used as an idiom (or a pattern) used throughout various articles on the Internet, or even in conversation, you’ll know that the developers in question are referring to the same programming strategy – just in a different way.

So Why Does This Matter in WordPress?

Just as design patterns in non-WordPress specific projects, such as larger applications, the design patterns provide a tried and true way to solve a common problem.

It helps to abstract our code a bit, keep our project easily maintainable, easily readable, and can actually help us to keep our code lean. This may result in us actually having more files in our project, but each file should have fewer lines of code.

This means that each file should have a specific purpose that should be clear, not only to us, but future developers as well.

What It Looks Like

Now, before we dive into the diagrams, talking about classes, and the strategies required to implement the actual pattern, I want to mention that we’re going to be taking a simple approach to this.

The thing is, the readership of this blog spans a wide array of experiences – we have some people who are learning to write code; others who are seasoned veterans.

In order to appeal to the majority of the readership, we need to strike a balance. So for those of you who have been involved with software engineering for years, this may seem overly simplistic; however, don’t skim it – perhaps you’ll pick up something new.

For those of you who are beginners or even intermediate programmers, pay close attention to what we’re discussing as it can provide dividends in future (or even existing) work.

The Purpose of the Simple Factory

So imagine this scenario: You’re working on a function that takes in a set of input – usually some type of unique string or integer – and you have this long if/else statement or perhaps you have this large switch/case statement that continues to grow as your project grows.

The problem is that the conditionals become a pain to manage. In fact case conditionals, or the case blocks, may actually end up doing as much work as a certain function should do.

This is where the Simple Factory comes into play. What we can do is abstract the details happening in each of the conditionals into their own class thus making it much easier to maintain and keeping the code much leaner.

And that is the Simple Factory Pattern.

A Look at the Pattern

So here are the key features of the Simple Factory Pattern:

Notice that the Plugin class has a private reference to the Factory class

The Factory class encapsulates all of the logic to return an object of the type User

The User class is a base class for three other classes: Admin, Volunteer, Reader, and the idea is that each of these types are subclasses of users with unique functionality of their own

The Plugin will receive a certain type of input that it will pass to the Factory

The Factory will examine the input and then, based on its value, will return one of the three user types

Nothing too complicated, right? Honestly, I think that the diagram is a bit more complicated than the principles at play. It really provides a lot of flexibility especially whenever you’re looking to introduce another User type like an Editor or something similar.

Note: This is not to be confused with WordPress’ built-in user types. This is simply an example to show what the pattern would look like.

A Working Example

Now that we’ve taken a look at the diagram for the pattern, let’s take a look at the source code in action. Below, we’ll look at the source code for each class and then I’ll provide a download to a fully documented demo after the discussion.

The Plugin

First, let’s look at the plugin class. Remember, this is nothing more than a prototype of what the pattern looks like. It’s not the same thing as a fully developed WordPress plugin.

<?php include_once( 'simple-factory.php' ); class Plugin { private $factory; public function __construct() { $this->factory = new Simple_Factory(); } public function get_user( $permission ) { return $this->factory->get_user( $permission ); } } ?>

Notice that the plugin is relatively simple:

It includes the simple-factory.php script in the header of the file

It then defines a constructor in which it sets the $factory property to an instance of the Simple_Factory

The only method available in the plugin is get_user which returns a user based on a type

We’ll see how this comes into play after we’ve examined all of the other classes.

The User

The User is an abstract base class that provides a basic constructor and an abstract function that must be implemented by all other subclasses.

<?php abstract class User { private $role; public function __construct( $role ) { $this->role = $role; } abstract public function get_role(); } ?>

Note that this class is intended to be subclassed by a variety of other classes, each of which we’ll look at in detail momentarily.

The Administrator, The Reader, and The Volunteer

The following four classes are all separate files each of which subclass the User base class. I’ve opted to include them all here together because there’s so little deviation from their actual implementation that it should be easy enough to follow.

The Administrator

<?php class Admin extends User { public function __construct() { $this->role = "Administrator"; } public function get_role() { return $this->role; } } ?>

The Reader

<?php class Reader extends User { public function __construct() { $this->role = "Reader"; } public function get_role() { return $this->role; } } ?>

The Volunteer

<?php class Volunteer extends User { public function __construct() { $this->role = "Volunteer"; } public function get_role() { return $this->role; } } ?>

As usual, leave me questions in the comments; otherwise, review the code then be sure to read up on The Simple Factory which is the next section – it ties all of this together.

Also, remember that all of this code will be shared at the end of the article along with code comments that describe exactly what’s happening.

The Simple Factory

The Simple_Factory class is really the crux of the entire pattern. Here is where all the decisions are made and the appropriate objects are returned.

<?php include_once( 'users/user.php' ); include_once( 'users/admin.php' ); include_once( 'users/volunteer.php' ); include_once( 'users/reader.php' ); class Simple_Factory { public function get_user( $permission ) { switch( strtolower( $permission ) ) { case 'read-write': $user = new Admin(); break; case 'help': $user = new Volunteer(); break; case 'read': $user = new Reader(); break; default: $user = null; break; } return $user; } } ?>

Note that the Simple_Factory includes the base user class and its subclasses and then works to return the appropriate type of user based on the incoming set of permissions.

The Advantages of the Simple Factory Pattern

Though it should be a bit obvious by this point in the article, the Simple Factory Pattern provides a number of advantages especially if you’re used to working with large conditionals.

It provides an elegant way to abstract your code so there’s less visual clutter

It allows you to introduce specialized, focused classes with a single purpose (which is great if you follow the SOLID principles)

It makes the code more maintainable as there’s a single place where classes are instantiated, and each class serves a single purpose

Overall, this is one of my favorite patterns simply for the matter of code organization and specialization that it can bring to the table.

Conclusion

Finally, you can checkout the entire source code – complete with documentation and installation instructions – on GitHub using this link.

At this point, we’ve taken a look at three patterns:

The Observer Pattern

The Singleton Pattern

The Simple Factory Pattern

This series could go one for a while; however, I think that we’ve covered enough ground at least to get many of us started with implementing patterns into our work.

So in the last article in the series, we’ll recap what we’ve learned and I’ll also recommend some other patterns, their purpose, and some further points of research that should continue to aid you in continuing to learn about design patterns and their advantages not only in WordPress development, but general software development, as well.

Other parts in this series:Design Patterns in WordPress: The Singleton Pattern