I know what it’s like to be a beginner in software development. I remember having no idea what I was doing (and still don’t sometimes 😃) and it took all the effort I had just to end up with some #basic code that performed the simplest of tasks. I spent countless hours debugging small issues that I was sure I would never figure out, all the while wondering why I was even bothering learning web development since I, obviously, was not that good at it.

And then one day, things started to make sense. I started understanding how things worked and could build meaningful apps. It’s as if something had clicked and I suddenly understood “programming”. The path to that place took some time, but reflecting back on those days, there were definitely some things that helped me progress a lot faster than others, and I am going to share those things with you. Here are 7 things that will help you as a beginner programmer transition into a more seasoned programmer.

1. Build things

Yeah, I know. This seems kinda obvious, but it’s true. Build as many “throw away” apps as possible. I mainly use Laravel and I am always creating new projects just to test stuff out. Figuring out what Object Oriented Programming is? Create a small project, quickly, that allows you to practice what you are learning.

I have my local environment set up so that it is easy for me to start a new project. You should take some time to make sure you local environment allows you to start projects quickly. When you are starting out, don’t let all of the bells and whistles of Docker vs Vagrant vs “who knows what” get in your way. If it takes using MAMP or WAMP just so you can start a project quickly, do that. Spend more time writing code than fixing your local environment.

When you start building things, make sure you are building things that integrate with API’s. You will learn a ton working with the different API’s out there. Check out the big tech players’ API’s like Facebook, Twitter, Github and Google. Lot’s of companies use those API’s and it will only benefit you to play around with them.

Above all, just build things. To-do apps, messenger apps, forums, blogs, anything and everything. Just build. Run into a road block and can’t think of something to build? Go here.

2. Just finish

Speaking of building things, you should get into a good habit of always finishing what you build. This will be one of your greatest habits. Because, one day, you may want to build a real product, and everything will get in your way and try to keep you from finishing. Got kids? Got a significant other? A job? Are you breathing? If you said “yes” to any of those, you will struggle to finish what you start. So, start now and build the healthy habit of finishing. See projects through to their completion. Also, this will give you a nice portfolio when it comes time to look for a job.

3. Code dive (no equipment necessary 🌊)

What is code diving? It’s when you look at source code and try and figure out what it does. I will choose a module in Laravel and I will look at all of the code for that module and try and figure out what is going one. There are tons of advanced techniques used in the Laravel framework and they will bring about many questions when you see them. When you run into a piece of code that you don’t understand, Google it and figure out what it does. If you can’t find an answer, use StackOverflow, or better yet, Laracasts. There are tons of great people in the Laravel community just waiting to help you!

If you’re not a Laravel developer, no worries! Just search for the most popular framework or library that is in your language (as long as it’s open source), and start code diving.

This is literally one of the things that helped me the most in becoming a better developer. One of the main reasons it has helped is because when I run into an issue, instead of running to Stack Overflow immediately, I don’t mind diving into the source code to figure out what is going on. This gives a true understanding of the code that is being used and will help tremendously in becoming a better developer,

4. Explore other languages

One of the things that made me a better developer was looking at other languages. I was always intrigued by Rails, so I decided to check out Ruby. I spent quite a few weeks learning some of the language and it really taught me a lot about PHP, believe it or not. It forced me to think outside of how I normally think when using my day-to-day language.

Now, if you are very new to software development, be careful with this one. Be sure a get a fairly good understanding of your main language first. You don’t want to try and take on too much at once, because that could actually be counter productive. Gather a good foundation of your chosen language and then think about exploring other languages.

5. Just getting things working isn’t enough

I remember the days of, “If I can just get this to work…”. I would spend a lot of time just trying to get something to work and then neglect the fact that once I got it to work, it needed to be refactored. Or, maybe there was a better way to solve the problem that provided a cleaner solution.

Whenever you solve a problem, I would challenge you to look at your solution and give a little more thought into how you can make it better. Can you clean it up a little by refactoring some extra methods out of it? Does it need to be extracted so that you can reuse it? Are your variables and methods named so well that they describe exactly what they are doing? Does it need comments because it’s a specific edge case that other developers may need to know about?

Take the extra step to make it better even after you’ve spent x amount of hours just trying to get it to work.

6. Test your code

Test. Your. Code. At least learn about testing. I had no idea what a test was until I had been programming for about a year and a half. When I was learning some Ruby, the tool that I was using to learn ran tests on the exercises that I was performing. I was intrigued by the notion that there was some code that tested my code. It didn’t take long for me to gain an interest in testing, and then, of course Test Driven Development, but I digress…

If you want to progress to the next level, learn about testing and learn how you can incrementally adopt testing with the code that you are writing. Not only will it help you gain confidence in the code that you have written, it will force you to write testable code, which will, in turn, make you a better developer.

7. Help others

This is part of the process. Find someone that wants to learn and pass on as much knowledge as you have and help them grow. You would be amazed at how much it helps you learn just by helping others.

But, more importantly, help because it’s what we, as developers, do. Have you thought about that? How many developers out there maintain their own open source projects that others benefit from? They are constantly resolving issues, updating their code bases, and most of them do it for nothing. Not. A. Penny.

Oh, and have you ever posted anything on Stack Overflow? There are hundreds, if not thousands, of developers there just waiting to help you solve a problem you may have. All for nothing.

Basically, you should give back to a community that has given so much to help you.

Conclusion

Learning to code is like anything else in life (but way better)… You will get out exactly what you put in. Spend a lot of time writing code and use these 7 ideas to help guide you in becoming a better developer. Write lots of code and be patient. Things will start to make sense and then one day, you won’t be a beginner any more.

What helped you become a better developer when you started? I would love hear what helped you most.

7 ways for the beginner programmer to become better, faster was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

Once that is finished, all you will do to create a site is:

You now have a fresh install of Wordpress running on Nginx. Simple.

Here are a few of my favorite things about EasyEngine.

Wordpress Install

Now, I would challenge you to look more into their different commands. For instance, if you want to create a Wordpress site and configure it for the W3 Total Cache plugin so that your site is crazy fast. All you have to do is enter:

It will automatically set up the server with the correct caching settings for the W3 Total Cache plugin. You don’t have to worry about messing with Nginx config files, or configuring the servers cache — it is all configured and ready to go.

What about Wordpress multisite? Here you go:

or

It really is so simple to use and it always works.

Organization

One of my favorite aspects of the EasyEngine tool is the organization that it provides. I have a few servers that I manage and they all use EasyEngine. No matter what server I am on, I know that all of my sites are organized neatly in the /var/www/. It doesn't choose some user folder to put them in like, say... Server Pilot (which also costs money to do anything significant). This means that I can go to my www folder and type ls -l and see all of the sites that reside on that server. Of course, I could just use the EasyEngine shortcut of ee site list and have a nicely printed out list of all of the current sites. Again, so simple.

Nginx Config, if you have to…

Sometimes you may find that you have to edit Nginx conf files. It seems that I can never remember the path to the available-sites folder on the system. This means that I have to either google it or I will look in every single folder until I find the right path (yes, I should probably learn grep but I just haven't taken the time yet). This is so easy with EasyEngine. Ready? ee site edit example.com Yep. That's it.

Letsencrypt (Can you say free SSL/TLS certificate?)

I have been very intrigued by the Letsencrypt open source initiative. I would love to have a free SSL certificate! While Letsencrypt is still in beta, they are moving fast to produce just that — free site encryption using SSL/TLS. EasyEngine is moving fast and has already implemented support for Letsencrypt.

Now, there is a caveat to Letsencrypt and that is the certificate age. A single certificate will only last 90 days and then a new one must be obtained. This would require some server commands in order to make this happen. This is not a huge deal, but I don’t want to have to set a 90-day reminder to remind me to log in to my server and re-install another certificate. This would be a huge nightmare if you had quite a few sites.

EasyEngine to the rescue! Once I updated my current sites with ee site update example.com --letsencrypt, EasyEngine creates a cron job that will automatically update the sites SSL every 90 days. That is just too sweet.

Side note

If you use the --letsencrypt switch on one of your sites, be sure and set an DNS A record for www and non-www of that site. Even if you are setting up on a subdomain, you need to do this. Hopefully, this saves someone some headache.

Closing

EasyEngine really is a timesaver. I know some server management, but that is mostly on the Microsoft side, so learning to be a DevOps is not a high priority on my list. If you, too, want to save some time on setting up and managing sites, I highly recommend giving EasyEngine a shot. Let me know if you have any questions or comments! You can find me on Twitter at @dericcain

Easy site management with EasyEngine was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

Currently, I am working on a rather large project and I have clearly seen the benefits of keeping your code decoupled. Now, I’m not going to go all extreme here and say that everything should be decoupled in the utmost fashion, but I will give you a very simple example of how decoupling can save you a major headache when things change in your codebase.

I work mainly with Laravel, so I will give an example using Laravel’s Eloquent models, but this example can be applied easily to a non-Laravel project.

Let’s say you have a User model and for that model, you have an attribute column in your database named is_admin to denote who the admins are within your application. At various places in your application, you need to check to see if the authenticated user is an admin so you know whether the user can do specific things. Here is what you would do:

if (Auth::user()->is_admin) {

    // they can do whatever they want

}

This works like a charm so you use it in a ton of places in your application. I mean, this works until your customer says, “Well, we need two different kinds of admins.”

This example may still work, but it may not. You may have to rename the is_admin column in your database to something different, and since you have your code so tightly coupled with your database, you will need to search for all of the places that you checked for is_admin and update it with the new column name.

A little looser

Instead of taking the above approach, a very simple solution would be to create a method on your user model that checks to see if they are and admin. Let’s see what that looks like.

class User extends Model

{

    public function isAdmin()

    {

        // If the column changes again, just change
        // it here and you’re good to go

        return $this->is_admin;

    }

}

Now, you can do your checks within your application like so:

if (Auth::user()->isAdmin()) {

    // they can do whatever they want

}

And if your database column name changes, it’s all good. All you have to do is change it once in your model because your isAdmin() method takes care of the check for you.

I know this is an elementary example, but its an easy example to understand and its a great starting point and way to start thinking about how your application code should be loosely coupled in order to make your life easier.

Simple example of decoupling your code was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

Creating the Repository Interface

If you don’t know what interfaces are, have a look here before you go any further. We need an interface to act like a contract for our repositories. What do I mean by contract? Just like a written contract which descibes the confines of a specific obligation, an interface is the same for our code. It says that any class implementing the interface must perform specific actions. Or, in our case, must contain specific methods.

I will use the ever-popular blog scenario and create a post repository, as well as a comment respository. So, create a folder inside of the app folder and name it Repositories. Then, create a file and name it PostRepositoryInterface.php. This will be our interface. Within that interface, you will want to add this code:

<?php

namespace App\Repositories;

interface PostRepositoryInterface

{

}

Now, we will need to the contracts, or methods, that we want our PostRepository to implement. It will looks something like this:

<?php

namespace App\Repositories;

interface PostRepositoryInterface
{
   /**
     * Get's a post by it's ID
     *
     * @param int
     */
   public function get($post_id);
  
   /**
     * Get's all posts.
     *
     * @return mixed
     */
   public function all();
  
   /**
     * Deletes a post.
     *
     * @param int
     */
   public function delete($post_id);
  
   /**
     * Updates a post.
     *
     * @param int
     * @param array
     */
   public function update($post_id, array $post_data);
}

Notice how there are not opening and closing curly braces. That is because no logic is stored in the interface — only the methods that we want our class to implement.

Creating the Repository

Now, we need to create our class. Within the same folder, `Repositories`, create a file and name it `PostRepository.php`. For this class, we will use the `implements` keyword to specify that we want to implement our interface. It should look like this:

<?php

namespace App\Repositories;

class PostRepository implements PostRepositoryInterface

{

}

We must create the methods that declared in our interface. If we don’t, we will get an error at runtime and we will not be able to use our class. We will want to go ahead and add the logic that we will use to work with out posts. For this, I will include our Eloquent model `Post`.

<?php

namespace App\Repositories;

use App\Post;

class PostRepository implements PostRepositoryInterface

{

/**

* Get’s a post by it’s ID

*

* @param int

* @return collection

*/

public function get($post_id)

{

    return Post::find($post_id);

}

/**

* Get’s all posts.

*

* @return mixed

*/

public function all()

{

    return Post::all();

}

/**

* Deletes a post.

*

* @param int

*/

public function delete($post_id)

{

    Post::destroy($post_id)

}

/**

* Updates a post.

*

* @param int

* @param array

*/

public function update($post_id, array $post_data)

{

    Post::find($post_id)->update($post_data);

}

}

Our class is now happy because it is using all of the methods defined by our interface. Now that we have our class and our interface created, be need to register our repository with Laravel’s container.

Registering our Repository with Laravel’s IoC Container

Create a file called BackendServiceProvider.php within the same folder — Repositories. This file will serve as a connector to Laravel’s IoC Container and allow us to use depency injection to inject our repository interfaces. More on that in a second…

Here is the BackendServiceProvider.php:

<?php

namespace App\Repositories;

use Illuminate\Support\ServiceProvider;

class BackendServiceProvider extends ServiceProvider

{

public function register()

{

    $this->app->bind(

        ‘App\Repositories\PostRepositoryInterface’,

        ‘App\Repositories\PostRepository’

    );

}

}

The one thing to notice here is the order in which the interface and the class are bound. If you try and bind ’App\Repositories\PostRepository’ before ’App\Repositories\PostRepositoryInterface’, you will get an error. You must bind the interface first.

Still with me?

Just to make sure you’re following along, you should have a folder structure like this:

- app

 — — Repositories

 — — — BackendServiceProvider.php

 — — — PostRepositoryInterface.php

 — — — PostRepository.php

Of course, there will be other folders and files within the `app` directory, but you get the point.

Using the Repository in a Controller

It’s time to use our shiny, new repository. The place to use this is our controller. I will assume that you have a `PostController.php` class and that is your controller that handles everything to do with your posts. If you use some other controller, that is fine too. What we want to do is inject our interface into the controller when the controller gets instantiated. That way we can use the repository for all of our interactions with our posts model. Check it out:

<?php

namespace App\Http\Controllers;

use App\Http\Requests;

use App\Repositories\PostRepositoryInterface;

class PostController extends Controller

{

protected $post;

/**

* PostController constructor.

*

* @param PostRepositoryInterface $post

*/

public function __construct(PostRepositoryInterface $post)

{

    $this->post = $post;

}

/**

* List all posts.

*

* @return mixed

*/

public function index()

{

    $data = [

        ‘posts’ => $this->post->all()

    ];

    return view(‘templates.posts’, $data)

}

}

The first thing that we do is inject our PostRepositoryInterface into our constructor. Then, we set our $post instance variable to an instance of our PostRepository object through our interface. This allows us to call the methods in our PostRepository class like we did in the index() method. Now we can do this:

$this->post->update($data_array);

$this->post->delete($post_id);

$this->post->get($post_id);

This keeps us from directly accessing our model like Post::find($id); which adds another layer of abstraction to our application. Don’t forget, should we stop using MySQL and start using MongoDB, or some other backend technology, all we have to do is swap out our PostRepository logic. This works because we are accessing the repository through our interface. This means that the code in our controller would not change at all. That’s a big win!

More than one Repository? Sure.

So, you need to create another repository because just having one repository is lame. Right? All you need to do is create an interface and then create a repository. Then, register them with Laravel’s IoC Container in our backend service provider file. I’ll use a Comment model to show you how.

Our directory would now look like this:

app

- Repositories

 — — BackendServiceProvider.php

 — — — PostRepositoryInterface.php

 — — — PostRepository.php

 — — — CommentRepositoryInterface.php

 — — — CommentRepository.php

You would create the comment repository interface the same exact way as we did the post repository interface:

CommentRepositoryInterface.php

<?php

namespace App\Repositories;

interface CommentRepositoryInterface

{

    // Define all methods here but remember not to use curly braces.

    public function all(); // Like this..

}

And our CommentRepository.php

<?php

namespace App\Repositories;

use App\Comment;

class CommentRepository implements CommentRepositoryInterface

{

    // Must use all methods that were defined in the CommentRepositoryInterface here

public function all()

{

    return Comment::all();

}

}

The last thing that you will need to do is register it with the IoC Container in our BackendServiceProvider.php. That file will now look like this…

<?php

namespace App\Repositories;

use Illuminate\Support\ServiceProvider;

class BackendServiceProvider extends ServiceProvider

{

public function register()

{

    $this->app->bind(

        ‘App\Repositories\PostRepositoryInterface’,

        ‘App\Repositories\PostRepository’

    );

    $this->app->bind(

        ‘App\Repositories\CommentRepositoryInterface’,

        ‘App\Repositories\CommentRepository’

    );

}

}

Again, pay attention to the order in which you list your interface and class.

Finished. Doesn’t that feel good?

You should have a fully functional repository design pattern implemented with Laravel 5. If you have any questions or comments, follow me up on Twitter!

Using the Repository Pattern in Laravel 5 was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

One of the most used data types in development is arrays. They are used so much, in fact, that PHP has a ton of different built-in array functions. I am going to do a series of the different array functions that PHP offers. Let’s look at a couple and how they can be useful.

array_unique()

If you have an array that may contain duplicate values, array_unique() could come in handy to help you get only the values that are unique. Think of it like MySQL’s DISTINCT clause For example…

$colors = [
  'red',
  'green',
  'yellow',
  'green',
  'blue',
  'red'
];

$unique_colors = array_unique($colors);

// Output...
$unique_colors = [
  'red',
  'green',
  'yellow',
  'blue'
];

It’s an easy way to get an array without the duplicate values.

array_map()

If you need to apply a function to all of the values in an array, array_map() is a great function for that. Let’s say we have a form with quite a few fields which we want to collect and pass to a DB. Of course, this form will need to be sanitized. array_map() can help us with that. We will create a method called sanitize()

Disclaimer: I am in no way saying this is all you need to do to secure user inputted data. This is just an example of a helper

/**
 * Sanitizes the $_POST array.
 *
 * @param $post_data
 * @return array
 */
public static function sanitize($post_data)
{
  // Take the parameter and use a callback function to clean the data.
  // $post_field represents each input field in the form
  $post_array = array_map(function ($post_field) {
    // Run strip_tags and trim the data from the field
    return strip_tags(trim($post_field));
  }, $post_data);

  // Send the sanitized array back
  return $post_array;
}

Now, we have a static method that can be called when we need to sanitize some user inputted data. We can call it like Validate::sanitize($_POST) assuming that the sanitize() method lives in the Validate class. Of course, you are not limited to just applying sanitize methods to each class, you can apply any function needed to each value in the array.

I will look at some more array functions in another post. If you have any suggestions or comments, follow me on Twitter and give me shout!

Arrays are everywhere! was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

May 2nd, 2016

Over the last year, I took part in three large projects. My task was to move away from the old architecture based on PHP and server-side HTML generation, and transition to REST API.

With the old approach, back-end developers were expected to know much more about the UI and visual aspects of the application. Because of this, they had to pay attention to different segments of the application, instead of focusing on their primary objective. Having the back-end API strictly separated from the UI allowed our developers to focus on the quality of their code.

Also, testing API services is much easier as REST API can be verified by automated unit testing.

I’ve had some experience in writing my own framework, as well as working with Yii, CakePHP, CodeIgniter, Slim Framework, Symfony and few other open source frameworks. Each time, I’ve experienced a lack of functionality or awkward approach to some problems.

I used Laravel for four months before deciding to choose it as the platform for our next project. The project itself was a great success and this article is a product of this experience. Now I am able to call myself a Laravel developer.

Why I Chose Laravel

I’ve already outlined some of my reasons for using Laravel and my experience, so let’s take a closer look at what made Laravel a better choice for my latest project:

• Quick and functional core that can be extended
• Clean and simple routing
• Effective ORM and database layer
• Easy integration with third-party libraries (AWS, export libs, etc.). You can use Composer or Packagist to include libraries in your project
• Active and growing community that can provide quick support and answers
• Supporting unit tests out of the box
• Async queue and background jobs for the long running tasks

Laravel Core And Routing

The Laravel kernel is hosted on GitHub. The kernel implements an IoC pattern allowing customization and rewriting of any part of the framework (request, logging, authentication, etc.).

Laravel designers didn’t spend too much time reinventing the wheel. A lot of solutions and practices are transferred from other frameworks. A good example of this approach is the extended Symfony console called Artisan, which is a command-line interface included with Laravel.

Routing

Routing in Laravel is amazing; it is very similar to the Ruby on Rails (RoR) implementation, which I like a lot. You can easily group routes, create resources for CRUD pages, attach filters and automatically bind models to the request parameters.

Nested routes are a very useful feature:

Route::group(['prefix'=>'level0'], function() { 
    Route::get('/', array('uses' => 'TestController@level0'));
    Route::group(['prefix'=>'/{level0}/level1'], function(){
        Route::get('/', array('uses' => 'TestController@level1'));
        Route::post('/{custom_variable}/custom_route', 
            array('uses' => 'CustomConroller@custom_route')); 
        }); 
    });

});

Versioning can be implemented as a group on the top level for all nested routes by using the ‘v1’ prefix. When we change the API version, we can retain the old one and use the ‘v2’ prefix to start implementation of routes with new code and logic, i.e., new references to controllers and actions.

Let’s take a step-by-step look at everything used in this Laravel tutorial:

A defined group of routes with path level0 at top level of our API.

If we have a call BASEURL/level0, then Laravel will resolve it and call method level0() of TestController to process the request.

We have a sub-group with the {level0}/level1 pattern. To access API resources inside this group we should use the path for the parent group (level0) and match the pattern of our sub-group ({level0}/level1). For example, level0/777/level1 is the correct path for this sub-group of our API. Here we have 777 as the variable level0 that Laravel will path to the handler of the routes inside the sub-group.

In the the end we have two sample routes:

BASEURL/level0/777/level1 - GET request to this URI will be processed with method level1($level0) of TestController where the first parameter is {level0} and it will be initialized with value 777.

BASEURL/level0/777/level1/888/custom_variable - POST request to this URI will be processed using the custom_route($level0, $custom_variable) method of CustomController.

The parameters used in the method come from the route variables.

Finally, we can associate our variable {level0} in the route with a model, i.e., LevelModel. In this case, the framework automatically tries to find existing database records and pass it on as a parameter to the controller’s method.

It helps us write less code and we don’t need to write LevelModel::find($id) or LevelModel::findOrFail($id) in controllers.

The Dingo API package takes routing one step further.

Here are a few features that Dingo provides to the framework:

• Transformers: Special objects for response customization (e.g., type-cast integers and boolean values, paginate results, include relationships, etc.)
• Protect routes and allow different/custom authentication providers. Controller Trait provides protection of custom actions, while we can easily retrieve authenticated user info with API::user().
• Limiting request count per user by using built-in or custom throttles. A powerful internal requests mechanism that allows requests on your API internally

Laravel uses Eloquent ORM

Laravel is based on Eloquent ORM. I’ve used it with PostgreSQL and MySQL, and in both cases it performed flawlessly.

The official documentation is comprehensive, so there is no reason to repeat things in this article:

Query Scope — query logic is created as a function with a special scope prefix.

The following example shows the standard SQL Query transformed to a query function in Eloquent ORM:

SELECT * WHERE hub_id = 100 AND (name LIKE `˜%searchkey%` OR surname LIKE `˜%searchkey%`):

function scopeByFieldListLike($query, $fields, $value){ 
    $query->where(function($query) use ($fields, $value){
        foreach($fields as $field){ 
            $query->orWhere($field , 'like', "%".$value."%"); 
        } 
     }); 
     return $query; 
}

Using a function in your code is straightforward.

$model = new User; $model->byFieldListLike(['name', 'surname'], 'searchkey');

A lot Eloquent methods return an instance of the QueryBuilder. You can use almost all of these methods on models.

Like what you’re reading?Get the latest updates first.

Enter your email address… Get Exclusive Updates No spam. Just great engineering and design posts.

Unit Testing

Writing unit tests is usually very time consuming, however, it’s definitely worth the time, so please do it.

Laravel relies on a TestCase base class for this task. It creates a new instance of the application, resolves the route and runs the controller method in its own sandbox. However, it does not run application filters (App::before and App::after) or more complex routing scenarios. To enable these filters in a sandbox environment, I had to manually enable them by using Route::enableFilters().

Obviously, if you know how to use Laravel, you know it could use some more work in the unit testing segment. I’ve set up a few functions that helped me create more advanced unit tests. Feel free to take these and use them in your projects.

To perform more advanced real-life testing and implement “curl-like” requests, I used the kriswallsmith/buzz library. This provided me with a much needed feature set for testing, including custom headers and uploading files.

The code below shows the function you can use to execute this kind of test:

public function browserRequest($method, $resource, $data = [], $headers = [], $files = [])
{
    $host = $this->baseUrl();
    if (count($files)){
        // Use another form request for handling files uploading
        $this->_request = new Buzz\Message\Form\FormRequest($method, $resource, $host);
        if (isset($headers['Content-Type'])) {
            // we don't need application/json, it should form/multipart-data
            unset($headers['Content-Type']);
        }
        $this->_request->setHeaders($headers);
        $this->_request->setFields($data);
        foreach($files as $file) {
            $upload = new Buzz\Message\Form\FormUpload($file['path']);
            $upload->setName($file['name']);
            $this->_request->setField($file['name'], $upload);
        }
        $response = new Buzz\Message\Response();
        $client = new Buzz\Client\FileGetContents();
        $client->setTimeout(60);//Set longer timout, default is 5
        $client->send($this->_request, $response);
    } else {
        $this->_request = new Buzz\Message\Request($method, $resource, $host);
        $this->_request->setContent(json_encode($data));
        $this->_request->setHeaders($headers);
        $response = new Buzz\Message\Response();
        $client = new Buzz\Client\FileGetContents();
        $client->setTimeout(60);//Set longer timout, default is 5
        $client->send($this->_request, $response);
    }
    return $response;
}

I am a very lazy developer, so I added optional parameters that allowed me to decode responses, extract data, and check the response codes. This led to another method that includes default headers, authorization tokens and some additional functionality.

public function request($method, $path, $data = [], $autoCheckStatus = true, $autoDecode = true, $files = [])
{
    if (!is_array($data)){
        $data = array();
    }
    $servers = ['Content-Type' => 'application/json'];
    if ($this->_token){
        $servers['authorization'] = 'Token ' . $this->_token;
    }
    $this->_response = $this->browserRequest($method, $path, $data, $servers, $files);
    if ($autoCheckStatus === true){
        $this->assertTrue($this->_response->isOk());
    } elseif(ctype_alnum($autoCheckStatus)){
        $this->assertEquals($autoCheckStatus, $this->_response->getStatusCode());
    }
    if ($autoDecode){
        $dataObject = json_decode($this->_response->getContent());
        if (is_object($dataObject))
        {
            // we have object at response
            return $this->_dataKeyAtResponse && property_exists($dataObject, $this->_dataKeyAtResponse) ? $dataObject->{$this->_dataKeyAtResponse} : $dataObject;
        }
        elseif (is_array($dataObject))
        {
            // perhaps we have a collection
            return $this->_dataKeyAtResponse && array_key_exists($this->_dataKeyAtResponse, $dataObject) ? $dataObject[$this->_dataKeyAtResponse] : $dataObject;
        }
        else
        {
            // Uknown result
            return $dataObject;
        }
    } else {
        return $this->_response->getContent();
    }
}

Once again, my lazy habits made me add wrappers designed to test CRUD pages:

create($data = [], $autoCheckStatus = true, $autoDecode = true, $files = []) show($id, $data = [], $autoCheckStatus = true, $autoDecode = true) update($id, $data = [], $autoCheckStatus = true, $autoDecode = true, $files = []) delete($id, $data = [], $autoCheckStatus = 204, $autoDecode = false) index($data = [], $autoCheckStatus = true, $autoDecode = true)

A simple test code would look like this:

// send wrong request
// Validation error has code 422 in out specs
$response = $this->create(['title'=>'', 'intro'=>'Ha-ha-ha. We have validators'], 422);
// Try to create correct webshop
$dataObject = $this->create(
    $data = [
        'title'=>'Super webshop',
        'intro'=>'I am webshop',
    ]
);
$this->assertGreaterThan(0, $dataObject->id);
$this->assertData($data, $dataObject);

// Try to request existing resource with method GET
$checkData = $this->show($dataObject->id);
// assertData is also a help method for validation objects with nested structure (not a part of PHPUnit).
$this->assertData($data, $checkData);

// Try to update with not valid data
$this->update($dataObject->id, ['title'=> $data['title'] = ''], 422);

// Try to update only title. Description should have old value. Title - changed
$this->update($dataObject->id, ['title'=> $data['title'] = 'Super-Super SHOP!!!']);

// Then check result with reading resource
$checkData = $this->show($dataObject->id);
$this->assertData($data, $checkData);

// Read all created resources
$list = $this->index();
$this->assertCount(1, $list);
// TODO:: add checking for each item in the collection

// Delete resoure
$this->delete($dataObject->id);
$this->show($dataObject->id, [], 404);

Here is another useful function for validating response data including relations and nested data:

public function assertData($input, $checkData){
// it could be stdClass object after decoding json response
    $checkData = (array)$checkData;
    foreach($input as $k=>$v){
        if (is_array($v) && (is_object($checkData[$k]) || is_array($checkData[$k]))) {
            // checking nested data recursively only if it exists in both: response data($input) and expected($checkData)
           $this->assertData($v, $checkData[$k]);
        } else {
           $this->assertEquals($v, $checkData[$k]);
        }
    }
}

Queuing

Long running tasks are a common bottleneck in web applications. A simple example would be the creation of a PDF report and its distribution inside an organisation, which can take a lot of time.

Blocking user requests to perform this action is not a desirable way of addressing the issue. Using Queue in Laravel is a great way of handling and queuing long running tasks in the background.

One of the last issues was PDF generation and sending reports via email. I used a default queue driver for Beanstalkd, supported with the package pda/pheanstalk. It is very easy to add tasks to the queue

For example, generating and sending PDFs could be done like this:

\Queue::push('\FlexiCall\Queue\PdfSend', [....data for sending to job's handler..], 'default');

Our PdfSend handler could be implemented like this:

class PdfSend extends BaseQueue{
    function fire($job, $data){
        //.............................
        //..... OUR IMPLEMENTATION.....
        //.............................
    }
}

Laravel specifications suggest tracking a queue with — daemon options, but I use the supervisor daemon that keeps it running permanently:

php artisan queue:listen --env=YOUR_ENV

Queues are great for tasks like saving data. They can be used to repeat failed jobs, add sleep timeouts before executing jobs, etc.

Putting It All Together

I’ve mentioned few key points related to Laravel development in this Laravel review. How you put it all together and build your application will depend on your specific setup and project. However, here is a brief checklist of steps you might want to consider:

• Setup homestead Vagrant box prepared for development using Laravel and configured local environment.
• Add endpoints (configure routes).
• Add authentication layer.
• Add filters before/after application execution, giving you an option to run anything before and after application is executed. Additionally, you can define filters for any route.

My default “before” filter creates a global scope as a singleton and starts the timer for monitoring performance:

class AppBefore { function filter($request) {
    \App::singleton('scope', function() { 
        $scope = new AppScope();//My scope implementation
        $scope->startTimer(); 
        
        return $scope; 
     }); 
} 

The “after” filter stops the timer, logs it to the performance log, and sends CORS headers.

class AppBefore {
    function filter($request) {
        \App::singleton('scope', function() {
            $scope = new AppScope();//My scope implementation
            $scope->startTimer();

            return $scope;
        });
    }
}

Developing each of your modules will likely require these steps:

Setup data migration, and seed default data. Implement models and relations, transformers, validators and sanitizers (if needed). Write unit tests. Implement controllers and execute tests.

Wrap Up

I’ve been using Laravel for over a year. As with any technology, there were some teething problems, but I believe that learning Laravel has convinved me that it is an amazing framework. There are a few more things that I haven’t mentioned in this Laravel tutorial, but if you are interested in learning more, you may want to consider these points and features:

• Powerful model for subscribing and listening to application events.
• Support for Amazon SDK aws/aws-sdk-php.
• Caching.
• Own templating engine called Blade, if you like building the application “the old way” without RESTful backend and UI separation.
• Simple configuration.
• Built-in Stripe billing module.
• Out of the box localization.
• Catching and handling most errors.

Good luck and stay tuned, Laravel is a promising framework and I believe it will be around for years to come

** This was a guest post from here: https://www.toptal.com/laravel/why-i-decided-to-embrace-laravel

Why I Decided To Embrace Laravel was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

To be quite honest, Sublime Text was the first editor that I ever used. I was so new to coding that I didn’t really understand enough about editors to grasp a real difference. Somehow, I found out that I could get PhpStorm for free since I was a student, so I jumped at the opportunity to try something new. Plus, it looked like it was the Lamborghini of editors. So, I made the switch.

At this point, I just started learning Laravel and one of the things that I liked the most was the code completion that PhpStorm offered. It allowed me to scroll through methods. This really helped me in learning the Laravel framework. There was some issues with PhpStorm and Laravel Facades, but there is a package that fixes this. For the next year, I would use PhpStorm exclusively and I loved it. Here are some other features that I loved:

Customization — I am not sure there is a part of PhpStorm that is not customizable. This is a huge plus because I can cater it to how I want/need it to work.

Refactoring — PhpStorm makes it really easy to refactor a block of code to a method, rename a variable throughout your codebase, pull a method up to a parent class, etc. This is a huge timesaver.

Terminal — there is a built-in terminal that makes it quick and easy to run terminal commands.

Live Templates — These are basically snippets of code that can be produced by type a command. For instance, if I want to start a public function, all I have to do is type pubf and this appears:

public function ()

{

}

The good thing about this is that the cursor start before the parenthesis so I can name the method. When I hit tab, the cursor moves to inside the parenthesis so I can create parameters and then when I hit tab again, the cursor moves to the body of the method so I can start creating my method. But that’s just one example and there are many-many more.

Step Dubugging — Although this took me some time to figure out how to set it up, I have found that this is way better than using var_dump() or dd() everywhere, at least in a lot of cases.

Testing — Running tests inside of PhpStorm works really well too. It just keeps everything inside of the terminal so I don’t have to open a separate window.

There are many more features that I have not mentioned here and that’s just because PhpStorm is a huge IDE and has a ton timesaving features.

If PhpStorm is so good, why the switch?

I started a new job and I they provide a Mac Mini in which I use to write code all day. Of course, I installed PhpStorm as my editor but I noticed that it ran really slow. I mean, it was so slow that I just couldn’t use it. I would hit ⌘ + p to search for a file and start typing the filename. It took so long for the window to pop up that PhpStorm would miss the first few letters of the filename that I typed…. That’s how slow…. This was not feasible for me to accomplish my tasks. The thought of switching to something else broke my heart (not really but you get it).

In the red corner, Sublime Text! (*crowd cheers*)

I broke out Sublime Text and started using it. I bought Wes Bos’s book Sublime Text Power User , which I cannot recommend enough if you use Sublime. I spent a couple of weeks getting everything how I wanted it in Sublime Text and man, was it lightening fast. No more lag… I was sure that my development time had sped up because of how lightweight and fast Sublime is. I actually wondered why I had been using PhpStorm and not Sublime at this point. Here are some things that I like about Sublime.

Customization — It’s hard to beat the customization of PhpStorm, but Sublime may come close. And, most of the customization happens using JSON files, which makes it very simple.

Plugins — There are a crap-load of plugins for Sublime. Basically, anything I needed to do, Sublime had a plugin for it and I could configure most plugins to cater them to my needs.

Themes — There are a ton of themes out there to make the editor look how you want. You can even hack away at an installed theme and customize it even more.

Speed — I don’t think there is an editor out there that is as fast as Sublime. I haven’t tried them all, but Sublime is lightening fast.

If Sublime Text is so good, why change?

As much as I loved using Sublime text and was singing it’s praises, there were a few things that nagged me to no end. For instance, when I wanted to use an array nested inside a closure in PHP, it would never align the closing tags, which meant that I always had to correct it. Here is what it would look like before I fixed it:

Route::group(‘/users’, [

// cursor lands here

] function() {

    }) // I had to move this back 4 spaces every single time…

I know, that seems a bit picky, but when I do this multiple times a day, it gets very annoying. And there are many other things like this that made me miss PhpStorm so much.

One more example is when I would go to use Emmet in my HTML like so:

.container>.row>.col-sm-12>p.text

It would expand to this…

.container>.row>.col-sm-12><p class=”text”></p>

Which means I would have to ⌘ + z and then hit tab again and hope it worked. Not huge, but again, when I do this a lot during the day, it was really annoying.

And back to PhpStorm we go!

I convinced my boss to buy a SSD drive so I could install it into the Mac Mini that I used and he agreed. This made the machine a lot faster. I opened up PhpStorm to see if it was usable, and boy oh boy, was it ever. It seems the SSD did the trick and made it perform as expected. I have not looked back and I probably won’t. I. Love. PhpStorm. It saves me so much time with all of the features that it offers. Yes, Sublime is faster, but it doesn’t save me as much time as PhpStorm does.

Conclusion

I still use Sublime for quick and dirty things like editing a single file, etc., but I use PhpStorm on my projects and I am very happy with it. If you have a fast enough computer to handle PhpStorm, I cannot recommend it enough. I would not ditch Sublime Text, as you may find that it is a great editor and you may like it better. Just my opinion, nothing compares to PhpStorm and how great it is to use.

Why I switched from PhpStorm to Sublime… and the back to PhpStorm was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.

Aside from being a web developer, I am a husband and father and value my family above all. My personal core values are integrity and hard work. And, if it was possible to make coffee a core value, that would be one too :)

I would love to know if you have any tips for me or anything that you think that I would find interesting. Follow me on Twitter and let me know if you have any suggestions!

About was originally published in Geek Stuff on Medium, where people are continuing the conversation by highlighting and responding to this story.