Why should I even use Laravel?

Because it is a super clean, easy to use PHP framework. My personal experience (this is subjective) told me that it is way easier to understand than the whole Symfony framework (Laravel is built on Symfony) or the Zend Frameworks. Symfony and Zend are both great frameworks, for sure, but Laravel offers you simplicity.

Laravel enables you to use best practice coding techniques for object-oriented programming. It comes with a powerful set of features for building solid web applications and assists you with solving common as well as complex problems.

Why shall Laravel be used with the newest PHP version (best will be the upcoming PHP 7.4)?

Laravel makes heavy use of modern features within the PHP language. It is completely object oriented and uses e.g. typed input parameters which came with PHP 7.

The real great thing about PHP 7.4 is that it offers typed properties, covariant returns (more generic in subclass) and contravariant input parameters (more specific in subclass). This is extremely powerful (you should read more about it)!

What is Dependency Injection?

Definition (Wikipedia): “In software engineering, dependency injection is a technique whereby one object supplies the dependencies of another object. A “dependency” is an object that can be used, for example a service. Instead of a client specifying which service it will use, something tells the client what service to use. The “injection” refers to the passing of a dependency (a service) into the object (a client) that would use it. The service is made part of the client’s state. Passing the service to the client, rather than allowing a client to build or find the service, is the fundamental requirement of the pattern.

The intent behind dependency injection is to achieve Separation of Concerns of construction and use of objects. This can increase readability and code reuse.

Dependency injection is one form of the broader technique of inversion of control. The client delegates the responsibility of providing its dependencies to external code (the injector). The client is not allowed to call the injector code; it is the injecting code that constructs the services and calls the client to inject them. This means the client code does not need to know about the injecting code, how to construct the services or even which actual services it is using; the client only needs to know about the intrinsic interfaces of the services because these define how the client may use the services. This separates the responsibilities of use and construction.”

That means that an object either is provided with another required object within its constructor or it just specifies some interface which is used for type hinting in constructors or methods.

The purpose of this is to get rid of dependencies and to achieve loose coupling (and high cohesion).

What is a Service Container and what is the Laravel Service Container doing?

A Service Container (or dependency injection container) is simply a PHP object that manages the instantiation of services (i.e. objects). The Service Container in Laravel is a Dependency Injection Container and a Registry for the application. The advantages of using a Service Container over creating manually your objects are.

It is often called with App::bind App:make etc.

The service provider is creating concrete classes automatically when required.

Class dependencies can be managed on object creation and it is used as a registry.

Laravel does this with binding certain services to the App:

$this->app->bind('FooService', \App\Services\FooService::class);

Essentially we are telling Laravel: “Hey store this object in your bag of tricks and label it as FooService”. Remember to always bind your services within the register method of your service providers.

There are also events in the service container where somebody can register to.

What is a Service Provider?

Core part of a Laravel application, resides in Providers directory. Has usually a special purpose like e.g. Authentication, Translation, ….

Service providers are usually registered on application bootstrap. All service providers are registered in app/config.php.

A service provider has a register and a boot method. The register method is called early and is for registering with the Service Container, the boot method is called after all Services has been registered and therefore you can use all Service Container within it.

What is „type hinting“?

Methods / functions with typed input parameters (optional in PHP).

What is (dynamic) binding in Laravel?

Laravel usually means binding a service provider to the service container. Almost all service container bindings will be registered within service providers.

What is middleware?

A layer between a client request from the frontend and a resource (data) in the backend. Therefore the logical part oft he backend which glues certain programs / part of a program together. It simplifies backend resource requests.

Middleware also serves the purpose of load balancing (distributing requests), concurrency, securring the backend,  …

Laravel offers many Middleware objects. One middleware for instance is for authentication, but you can also use middleware for certain headers for instance.

What is a Facade?

A Facade is a programming design pattern. It usually offers a simplified standardized interface to a certain set of sub-systems.

In Laravel: Facades provide a “static” interface to classes that are available in the application’s service container. Laravel ships with many facades which provide access to almost all of Laravel’s features. Laravel facades serve as “static proxies” to underlying classes in the service container, providing the benefit of a terse, expressive syntax while maintaining more testability and flexibility than traditional static methods.

Examples for Facades in Laravel are calls to App::, Auth::, DB::, Cookie:: …

Facades can be useful because they are not required in class constructors, but they can also make an application complicated to maintain in case they get to large.

What is a Contract in Laravel?

Laravel’s Contracts are a set of interfaces that define the core services provided by the framework. The Illuminate\Contracts\Queue\Queue contract i.e. defines the methods needed for queueing jobs, while the Illuminate\Contracts\Mail\Mailer contract defines the methods needed for sending e-mail.

Contracts are often imported with the use keyword and used (e.g. in the constructor or some method). It is easy to write alternative Contract implementations and therefore they can be replaced easily.

What is PHP artisan?

PHP artisan is command line tool that makes your life easier. In fact, very much easier while working with Laravel. If you know about any MVC framework, you would know what I’m about to say, it can create models, controllers, seeders, migrations and many other things with minimum (or maximum) boilerplate code. It can also start a server and can do many other things.

How is routing working in Laravel?

Usually defined in routes/web.php (for API routs for instance routes/api.php is used). Basically defined with the Route Facade which offers the common HTTP methods and a callback function. Routes have certain rules for parameters (also wildcard), can be grouped, …

What are Controllers in Laravel?

Handling all requests within route files can be clumsy. Controllers can do the most important calls to the model/business layer and return everything properly.

What is the Request/Response object doing?

The service container can automatically inject Request/Response objects (e.g. into a certain Controller). It contains info like e.g. input parameters, cookies, and does some sanitation on it.

Routes and Controllers usually should return response objects or views. You can add headers and cookies, create downloads, define the output, …

How are views in Laravel working?

In most projects Blade is used as a template engine. The views are built with html and contain output injected by Blade.

How is validation in Laravel working?

Laravel has a powerful set of validation rules which can be performed on inputs (e.g. in Controllers).

How is Laravel to databases?

Laravel usually uses the Eloquent ORM mapper. It simplifies database communication and SQL statements with certain methods. It offers a query builder which simplifies queries.

How are migrations and seeding working in Laravel?

Migrations are like version control for your database, allowing your team to easily modify and share the application’s database schema. Migrations are typically paired with Laravel’s schema builder to easily build your application’s database schema. If you have ever had to tell a teammate to manually add a column to their local database schema, you’ve faced the problem that database migrations solve.

The Laravel Schema facade provides database agnostic support for creating and manipulating tables across all of Laravel’s supported database systems.

Laravel has a Seeder for seeding applications with defined or random data which is really helpful during development.

Be free to critizise this tutorial. Improvement ideas are always welcome! 😉 

This is its description:

Prevent users from logging into your WordPress installation for a certain timeframe or permanently. Works also great with the multisite user management area. The locked users are easily manageable within the users overview page. The settings are within the user edit pages. No user can lock himself. No user with a lower role can lock a higher user and administrators in a network can not lock super administrators. If a user is locked, he is instantly logged out of any session until the lock expires or is removed.

No useless overhead, no ads. Just a tiny, but very effective plugin to keep your website secure.

• you do not want to delete a user, but you want to make sure he can not access the site (at least for a certain timeframe)
• an employee leaves your company and access should be removed, but you want to keep his user as an author in the system
• you want to punish a certain user which did bad things for a certain timeframe
• you want only few persons to have access to your WordPress site in order to minimize risk of incidents
•  … or maybe some other use case

Would be great to hear whatever feedback or improvement ideas 😉 

Then the author suddenly has disappeared without a Word tens of thousands of WordPress sites have been affected. One year later some great guy appeared which improved qTranslate and developed it further und the name qTranslate X. Again a lot of developers and bloggers were using it. Guess what happend? The author has collected donations and again disappeared without a word. The project was abandoned again and tens of thousands of unhappy users were left behind.

After almost two years of silence I am really happy to announce that new authors have decided to continue the project with the name qTranslate XT. The project is not yet in the official plugin repository but it is available on Github: https://github.com/qtranslate/qtranslate-xt

You can replace old installations of qTranslate X and e.g. bugs with more recent versions of PHP are fixed!

All the best to the new team and I hope that the completely open source project will become even more popular in the future. This site is powered by qTranslate XT 😎 

Importing an SQL dump file:

mysql -u [user] -p [password] [database name] < [Path to Dump File]

Exporting an SQL dump file:

mysqldump -u [user] -p [password] [database name] > [Path to Dump File]

Example 1 (probably unwanted results):

var types = ["boring","stupid","funny"];

for(key in types) {
    var type=types[key];

    $.ajax({url: "/?connection=get&type="+type, success: function(result){
        $('#'+type).html(result);
    }
    });
}

Result: Only #funny is populated (with the results of the last callback, no matter which ends last).

Example 2 (solution):

var types = ["boring","stupid","funny"];

for(key in types) {
    var type=types[key];

    (function(type) {
        $.ajax({url: "/?connection=get&type="+type, success: function(result){
            $('#'+type).html(result);
        }
        });
    })(type);
}

Result: The elements with ids #boring, #stupid and #funny are populated with the result of the corresponding callback.

Explanation: You have created a closure which is preserving the value of type according to the current iteration.

Notice: Undefined index: not_set in /home/.sites/../../../…php on line 1

It happens if accessing the key of an array which does not exist.

There is a very similar problem with PHP objects: If you access a property of an object in PHP you just get an empty string ever knowing if the property even existed. PHP does not even throw notices in this case.

Some examples:

//
$array = array("a","b","c");
echo $array[2]; // returns "c"
echo $array[3]; // returns nothing, notice undefined index

//
$_POST["my_field"]; // returns the value if submitted, or a notice if that value was not submitted

//
$obj = new stdClass();
$obj->a = "12";
$obj->b = "whatever";

echo $obj->a; // outputs string "12"
echo $obj->c; // outputs nothing, not even a notice just empty string

In order to enable save and good programming with PHP experienced PHP developers check for type safety and save array key accesses within their applications which usually requires a lot of extra work. PHP provides some operators and methods which check for the existence of keys and properties as well as for their type safety.

Example: Check if the user has submitted the value “yes” for the field “update” from a form and the array $_POST at key update contains a string value of yes.

if(isset($_POST['update']) && $_POST['update'] === "yes")) {

}

Quite a lot of text to write right? There are a lot of native PHP methods which check for existence like isset(), property_exists(), array_key_exists() and more. Furthermore there are a lot of methods which check for type safety like is_int, is_bool etc. as well as the operators with the additional = like ===, !==.

However some time ago I somehow got annoyed by this behaviour of PHP especially. I developed a method which is especially useful in case a developer knows that a variable might not be populated and wants to set an adequate default value for this case. Furthermore I guarantees a type safe result for key/property access.

Just check out the following function and you may find it helpful, too:

/**
 * Constats representing the primitive types.
 */
class Primitive {
    const STR = 0;
    const INT = 1;
    const BOOL = 2;
    const FLOAT = 3;
}

/**
 * In case you are unsure if an array key/object property exists and you want to get a (possibly typesafe) defined result.
 * 
 * @param $var array/object: An array or object with the possible key/property
 * @param $key array/string: The key. For a multidimensional associative array, you can pass an array.
 * @param $empty: If the key does not exist, this value is returned.
 * @param $primitive: The type of the given variable (-1 for ignoring this feature).
 * 
 * @return The (sanitized) value at the position key or the given default value if nothing found.
 */
function resempty(&$var,$key,$empty="",$primitive=-1) {
    
    $tcast = function($var,$primitive) {
        switch(true):
            case $primitive === Primitive::STR:
                $var = strval($var);
                break;
            case $primitive === Primitive::INT:
                $var = intval($var);
                break;
            case $primitive === Primitive::BOOL:
                $var = boolval($var);
                break;
            case $primitive === Primitive::FLOAT:
                $var = floatval($var);
                break;
        endswitch;
        return $var;
    };

    
    if(is_object($var)) {
        if(is_array($key)) {
            $tpclass = $var;
            $dimensions = count($key);
            for($i=0;$i<$dimensions;$i++) {
                if(property_exists($tpclass,$key[$i])) {
                    if($i === $dimensions-1) {
                        return $tcast($tpclass->$key[$i],$primitive);
                    } else {
                        $tpclass = $tpclass->$key[$i];
                    }
                } else {
                    return $tcast($empty,$primitive);
                }
            }
            return $tcast($empty,$primitive);
        }

        if(property_exists($var,$key)) {
            return $tcast($var->$key,$primitive);
        }
    } else if(is_array($var)) {
        if(is_array($key)) {
            $tpar = $var;
            $dimensions = count($key);
            for($i=0;$i<$dimensions;$i++) {
                if(array_key_exists($key[$i],$tpar)) {
                    if($i === $dimensions-1) {
                        return $tcast($tpar[$key[$i]],$primitive);
                    } else {
                        $tpar = $tcast($tpar[$key[$i]],$primitive);
                    }
                } else {
                    return $tcast($empty,$primitive);
                }
            }
            return $tcast($empty,$primitive);
        }

        if(array_key_exists($key,$var)) {
            return $tcast($var[$key],$primitive);
        }
    }
    return $tcast($empty,$primitive);
}

// Examples:
resempty($array,"key"); // returns the value at postion "key" if set, otherwise empty string
resempty($obj,"key",-1,Primitive::INT); // returns an integer value, -1 in case the property of the object is not set, otherwise the integer value of the object at this place

Be free to tell me if you find this useful or if you have improvement suggestions.

1. GEO Meta Tags

2. Google Local Search Optimization

  

    
    

    
...
    
...
    

    ...

    ...

    ...

    ...

    
    

        
        
    
    

Improvement ideas in the comments are welcome 🙂

.parent {
  display:-webkit-box;
  display:-moz-box;
  display:box;
  -webkit-box-orient:vertical;
  -moz-box-orient:vertical;
  box-orient:vertical
}

.child1 {
    -webkit-box-ordinal-group:2;
    -moz-box-ordinal-group:2;
    box-ordinal-group:2;
}

.child2 {
  -webkit-box-ordinal-group:3;
  -moz-box-ordinal-group:3;
  box-ordinal-group:3;
}

.child3 {
  -webkit-box-ordinal-group:1;
  -moz-box-ordinal-group:1;
  box-ordinal-group:1;
}

Old box model – more info on the new flexbox model: https://css-tricks.com/snippets/css/a-guide-to-flexbox/

In many cases the problem is that the domain is with www. or without www. in the beginning which may differ from the old system. In this case you probably have to go to the “hosting settings” of your cPanel or whatever and set the domain correctly. The error will be gone afterwards.