Forem: Matt Sparks

🧠 Learn! 5 Github Repos With Great Free & Open Source Resources

Matt Sparks — Wed, 29 May 2019 14:08:06 +0000

Things move fast in web development. Here are 5 great Github repos with free and open source resources to fill up your mind grapes.

Free Books!

This list of free programming books comes to us from the Free Ebook Foundation. Subjects range from specific programming languages to topics like Machine Learning and Security.

EbookFoundation / free-programming-books

📚 Freely available programming books

This page is available as an easy-to-read website at https://ebookfoundation.github.io/.

List of Free Learning Resources In Many Languages

Intro

This list was originally a clone of StackOverflow - List of Freely Available Programming Books with contributions from Karan Bhangui and George Stocker.

The list was moved to GitHub by Victor Felder for collaborative updating and maintenance. It has grown to become one of Github's most popular repositories, with 160,000+ stars, 6000+ commits, 1600+ contributors, and 39,000+ forks.

The Free Ebook Foundation now administers the repo, a not-for-profit organization devoted to promoting the creation, distribution, archiving, and sustainability of free ebooks. Donations to the Free Ebook Foundation are tax-deductible in the US.

How To Contribute

Please read CONTRIBUTING. If you're new to GitHub, welcome!

How to Share

Books

English

Other Languages

Arabic / al arabiya…

View on GitHub

Open Source Documents

These documents are all open source and can be modified/redistributed/etc.

44bits / awesome-opensource-documents

📘 A curated list of awesome open source or open source licensed documents, guides, books.

Awesome Open Source Documents

This is not a list of free programming books. This is a curated list of open source or open source licensed documents, guides, and books which can be read, used, modified, translated, redistributed and even rewritten under their same license.

Document Template

[TITLE][repository-url] by AUTHOR ([SITE][site-url], LICENSE) - SHORT DESCRIPTION

Subjects
Programming Languages
- C
- Coffeescript
- CSS
- Fortran
- Ruby
- Clojure
- Erlang
- Elixir
- Forth
- Go
- Haskell
- Javascript
- Lisp
- Objective-c
- Ocaml
- Perl
- PHP
- Python
- Rust
- R
- Scala
Tools
- Editor
- Git
- Server
- etc.
Library Documentation
Other Languages
- Korean
- Chinese
- Japanese
License

Subjects

Computer Science

Crypto 101 (Site, cc-nc) - the introductory book on cryptography
The little book about OS development (Site, cc-nc-sa) - This is the source…

View on GitHub

Build Your Own X

When I came across this repo I immediately loved it. Want to build your own bot? How about your own programming language? This repo will help you get started.

danistefanovic / build-your-own-x

🤓 Build your own (insert technology here)

[Submit tutorial]

Tutorials

Build your own `3D Renderer`

View on GitHub

Awesome Tools For Junior Devs

A great list of resources for junior devs. Resources include tutorials, blogs, books, podcasts, and tons more.

stephhappens / awesome-tools-for-junior-developers

A curated list of popular tools, tips and tricks for aspiring developers.

Awesome list of tools you might need on your path to senior developer-dom

A curated list of popular tools, tips and tricks for aspiring developers.

To add to the repo simply grab the name, link and a short searchable description of your favorites. Try to keep it to high level products you have personally tried and would recommend to your friends and coworkers. Also tools that you wish you knew about when you were starting as a junior developer are welcomed!

Index

Tutorials

Wes Bos Javascript 30- Free vanilla Javascript course covering the basics of Javascript.
Egghead.io- A Mix of free and paid courses for Front End Frameworks and Javascript.
Linkedin Learning- A library of courses on a full range of a variety of topics. This was Lynda before.
The Bash Guide- Very good guide for…

View on GitHub

CS Video Courses

Ever wanted to take a computer science course from Harvard? This repo lists tons of free video courses from some of the best universities in the world.

Developer-Y / cs-video-courses

List of Computer Science courses with video lectures.

Computer Science courses with video lectures

Introduction

Please check NOTES for general information about this list.
Please refer CONTRIBUTING.md for contribution guidelines.

Courses

Introduction to Computer Science

View on GitHub

More!

There are some great resources being shared in the comments. Go take a look!

Get What You Want: Using PHP Collections to easily filter and manipulate data. 😎

Matt Sparks — Tue, 28 May 2019 19:06:54 +0000

You've worked with APIs, right? You make a request, you get some data back, and you do something with it. Pretty standard stuff. This tutorial will show you how you can use the power of PHP collections to easily get the data you want.

What are PHP collections? Simply put: a collection is a class that allows us to easily work with arrays.

For this tutorial, we'll be using the tightenco/collect package. This package allows us to use Laravel Collections without the entire framework.

tightenco / collect

A Collections-only split from Laravel's Illuminate Support

Collect - Illuminate Collections

Import Laravel's Collections into non-Laravel packages easily, without needing to require the entire Illuminate\Support package. (Why not pull Illuminate\Support in framework-agnostic packages)

Written by Taylor Otwell as a part of Laravel's Illuminate/Support package, Collect is just the code from Support needed in order to use Collections on their own.

Lovingly split by Matt Stauffer for Tighten Co., with a kick in the butt to finally do it from @assertchris.

Installation

With Composer:

composer require tightenco/collect

Development

If you are a developer working on Collect and you're tasked with upgrading it to mirror a new version of Laravel, run ./upgrade.sh from the root directory. You can pass a parameter to target a specific Laravel version (e.g. ./upgrade.sh 5.7.10) or, if you don't pass a parameter, the script will find the latest tagged release and run against that.

The upgrader will pull…

View on GitHub

Data for this tutorial was provided by the OMDb API.

Rather than embed the data, you can view it here.

A Simple Example

Before we get into parsing our movie data, let's do a quick example. In this example, we'll grab the first and last item in an array.

use Tightenco\Collect\Support\Collection;

$simpsons = ['Homer', 'Marge', 'Bart', 'Lisa', 'Maggie'];
$c = new Collection($simpsons);

echo $c->first(); // Homer
echo $c->last();  // Maggie

Pretty easy, right? We have an array which we use to make a new Collection instance. From there we use the first() and last() methods to grab "Homer" and "Maggie."

Getting Started

First, we need to first use Composer to pull in our Collection package.

composer require tightenco/collect

Now for each example, we need to include our dependencies and do a little setup.

<?php

require 'vendor/autoload.php';

use Tightenco\Collect\Support\Collection;

$json = file_get_contents(__DIR__ . '/data.json');
$movies = json_decode($json, true);
$c = new Collection($movies);

Collection Methods

The Collection package provides us with a ton of great methods we can use to manipulate our data. Since there are ~110 methods, I won't be going over each one. Instead, I'll highlight a few and explain their functionality.

`.map()`

The map() function loops through the data and passes each item to the given callback. You are then able to return the item to create a new collection. Below we'll create a new collection that contains only each film's title.

$titles = $c->map(function ($movie) {
    return $movie['Title'];
});

Result:

['The Matrix', 'Blade Runner', 'The Fifth Element', 'Escape From New York']

You're not limited to just returning a single value. Let's create a collection that includes each film along with the date of release.

$release = $c->map(function ($movie) {
    return [$movie['Title'] => [
        'releaseDate' => $movie['Released']
    ]];
});

Result:

[
    'The Matrix' => ['releaseDate' => '31 Mar 1999'],
    'Blade Runner' => ['releaseDate' => '25 Jun 1982'],
    'The Fifth Element' => ['releaseDate' => '09 May 1997'],
    'Escape From New York' => ['releaseDate' => '10 Jul 1981']            
]

Now, let's format the date.

$release = $c->map(function ($movie) {
    return [$movie['Title'] => [
        'releaseDate' => date('F d, Y', strtotime($movie['Released']))
    ]];
});

Result:

[
    'The Matrix' => ['releaseDate' => 'March 31, 1999'],
    'Blade Runner' => ['releaseDate' => 'June 25, 1982'],
    'The Fifth Element' => ['releaseDate' => 'May 09, 1997'],
    'Escape From New York' => ['releaseDate' => 'July 10, 1981']            
]

Side note: if this were a real project I would probably use PHP's DateTime or Carbon to format the date.

`.filter()`

The filter() method, well, filters the data. Any items that pass a given test will be returned. In the example below, we return any movie whose "Metascore" is at least 70.

$metascore = $c->filter(function ($movie) {
    return $movie['Metascore'] >= 70;
});

Result:

[
    [
        'Title' => 'The Matrix'
        ...
    ], 
    [
        'Title' => 'Blade Runner'
        ...
    ],     
    [
        'Title' => 'Escape From New York'
        ...
    ]   
]

`.sum()`

The .sum() method is handy when you want to total values. In this example, I use the map() method to return each movie's runtime and then total them to see how long it would take to watch all four films.

$runtime = $c->map(function ($movie) {
    /**
     * Breakdown:
     *
     * 1. Remove " min" from the string.
     * 2. Cast the string to an integer so we can add them
     */
    return (int) str_replace(' min', '', $movie['Runtime']);
})->sum();

Result:

`.count()`

Like .sum(), .count() is a very simple method that can really come in handy when you want to know how many items are in your collection.

$c->count(); // 4

Tips For Landing Your First Web Development Job

Matt Sparks — Thu, 23 May 2019 19:35:54 +0000

So, you've learned how to code and you're ready to land that first job? Great! Over the years, I've held a number of development jobs and hired a number of developers. Here are some tips, from my personal experience, that might be helpful in your job search.

Technical

Understand Git/version control

In modern development, you'll be hard-pressed to find a development team that doesn't utilize some type of version control. Nowadays Git is the king of VC, but Subversion and others are still in use.

A lot of junior developers I've interviewed have simply "known of" Git. While that's not a deal breaker, knowing the basics of Git can definitely give you a leg up on the competition.

Resources to Learn Git

Show Your Work

If you're just starting out, you likely haven't worked on very many projects. No worries! A junior developer isn't (or at least shouldn't be) expected to have a crazy-impressive resume.

That being said, you'll still need to demonstrate your knowledge and abilities.

This can be accomplished a few different ways:

Work on personal projects – a blog, a package/library, some random fun idea.
Contribute to Open Source.
School assignments.
See if any friends or family could use your skills (for a free or otherwise)

Research The Company

Find out as much as you can about your potential new employer. This will give you a better idea of what they do, what they use, and what you can expect during the interview.

For example, if you find through your research that most of their apps are built using Laravel – then it would be a good idea to make sure you're up-to-speed with that framework.

Continue to Learn

This isn't just a tip for getting a job. This is a life tip. Put new things in your brain as often as possible.

Non-Technical

Be Yourself

Don't try to be the person you think the interviewer wants you to be. If you don't know what something is or how to do something, don't try to fake it. You'll show up on your first day of work and be assigned to a task that you have no idea how to complete. That's not fun.

If you try to be something you're not, you're doing a disservice to yourself and the company.

You're awesome, so don't sweat it.

“We are what we pretend to be, so we must be careful about what we pretend to be.” ― Kurt Vonnegut

Try to Relax

I know that this tip is easier said than done. I struggle with anxiety and I've literally shaken through entire interviews. Take a deep breath and try to calm yourself. You'll be able to answer questions more thoughtfully and with more confidence. Just remember: that person interviewing you is just another human – with all the same human things going on in their head. If you don't get this job, there will be other opportunities.

I hope you find these tips useful. In an upcoming post, I'll share some tips on landing your first freelance client.

I'd love to know your tips for getting that first development job. Let me know in the comments!

Quick JavaScript Tip: the some() method

Matt Sparks — Wed, 22 May 2019 18:23:02 +0000

I recently learned of a great JavaScript method I'd never used. It was brought to my attention by Wes Bos. The some() method is a convenient way to test the values of an array and see if at least one value returns true. some() was implemented before ES6 and its support is wide-spread (Internet Explorer 11 supports it).

It's important to note that this method only works on true Arrays. Other iterable types do not implement this method.

Problem: You have an array containing the types of animals your hotel allows. How can you determine if your pet snake, Mr. Slithers, can come along on your trip?

An Older Way:

var animals = ['dogs', 'cats', 'snakes', 'birds', 'pandas'];
var snakesAllowed = false;

for (var i = 0; i < animals.length; i++) {
  if(animals[i] === 'snakes') {
    snakesAllowed = true;
    break;
  }
}

console.log(snakesAllowed); // true

Using .some():

// Using arrow functions
const animals = ['dogs', 'cats', 'snakes', 'birds', 'pandas'];

const snakesAllowed = animals.some((type) => type === 'snakes');

console.log(snakesAllowed); // true

// Using normal functions
const animals = ['dogs', 'cats', 'snakes', 'birds', 'pandas'];

const snakesAllowed = animals.some(function(type) {
  return type === 'snakes';
});

console.log(snakesAllowed); // true

Addendum:

@attacomsian mentioned in the comments that .includes() would be a better fit for the problem above. I completely agree. The example above was just to illustrate how .some() works rather than solve the problem in the most efficient way.

For another example to illustrate .some()'s functionality, let's say we have an array of comic book prices and we want to know if any cost more than $10.

const prices = [5, 8, 11, 10, 25];
const aboveTen = prices.some((price) => price > 10);

console.log(aboveTen); // true

Yet Another Resources List!

Matt Sparks — Tue, 21 May 2019 21:14:29 +0000

Recently, I did an AMA. It was a ton of fun and I hope those who participated got something out of it. A few of the questions centered around resources for web development. Because of that, I thought it might be useful to compile a list of tools, blogs, and tips.

Without further ado, I give you my list of resources that you've probably seen a billion times on other "list of resources." These are completely random and not very organized. Enjoy!

[Note: If a resource isn't free, I've marked it with an *]

API Related

Blogs/News

Error/Bug Tracking

Sentry

Git/Deployment/Continuous Development

JavaScript

Exploring ES6(online book)
JavaScript 30

Newsletters

PHP Weekly

Planning/Notes

NotePlan*

Random

Design Patterns

Reference

RegEx

Text Editors

Video Tutorials

Some Awesome Dev Folks on Twitter

in no particular order

Oh, you can follow me too if you'd like 🙃 @DevelopmentMatt

Please add any resources you use in the comments!

I've been coding for 20 years, Ask Me Anything!

Matt Sparks — Thu, 16 May 2019 20:11:46 +0000

My first website was built on GeoCities! I remember the original browser wars! I may or may not belonged to a webring or two.

I've worked for successful start up's, failed start up's, large companies, freelance, and everything in between.

Today I'm primarily a PHP developer, but I've written code in many different languages using many different tools and philosophies.

Building a PHP Framework: Part 8 - Routing

Matt Sparks — Fri, 10 Aug 2018 00:11:51 +0000

Originally posted on DevelopmentMatt.com

Part 7 got us up to speed on the container that will be used in the Analyze PHP Framework. In this post we'll cover how routing works in general and specifically within PHP.

How Routing Works

Routing is the process of parsing a URI and determining the appropriate action to take.

For example, consider the following URI:

https://example.com/login

How does a request like the one above result in a response to the user? Let's break it down:

The request is received by the application.
The application breaks down the request into its components. Things like: the method (ex: GET), host, path, etc.
The application looks for a defined route that matches this request.
Once found, it takes the defined action and returns a response.

A Laravel Example

For a real-world example, here's one way the above example could be implemented in Laravel.

Route::get('/login', function() {
    return view('login');
});

We define a GET route for the /login URI. When that route is requested we return a response – in this case, HTML for the login page.

How Routers Work

There are a number of routers in the PHP ecosystem. They range from the more simplistic to feature-packed behemoths. Although they differ in size and complexity, they generally employ the same fundamental steps: parse the request, match the pattern, run some code, return a response.

The Symfony router (probably the most widely used PHP router) does this.

As does this one.

And this one.

A Very Simple PHP Router

To demonstrate these concepts let's create a stupid simple, not at all useful, PHP router.

<?php
/**
 * First, let's define our Router object.
 */
class Router
{
    /**
     * The request we're working with.
     *
     * @var string
     */
    public $request;

    /**
     * The $routes array will contain our URI's and callbacks.
     * @var array
     */
    public $routes = [];

    /**
     * For this example, the constructor will be responsible
     * for parsing the request.
     *
     * @param array $request
     */
    public function __construct(array $request)
    {
        /**
         * This is a very (VERY) simple example of parsing
         * the request. We use the $_SERVER superglobal to
         * grab the URI.
         */
        $this->request = basename($request['REQUEST_URI']);
    }

    /**
     * Add a route and callback to our $routes array.
     *
     * @param string   $uri
     * @param Callable $fn
     */
    public function addRoute(string $uri, \Closure $fn) : void
    {
        $this->routes[$uri] = $fn;
    }

    /**
     * Determine is the requested route exists in our
     * routes array.
     *
     * @param  string  $uri
     * @return boolean
     */
    public function hasRoute(string $uri) : bool
    {
        return array_key_exists($uri, $this->routes);
    }

    /**
     * Run the router.
     *
     * @return mixed
     */
    public function run()
    {
        if($this->hasRoute($this->request)) {
            $this->routes[$this->request]->call($this);
        }
    }
}

/**
 * Create a new router instance.
 */
$router = new Router($_SERVER);

/**
 * Add a "hello" route that prints to the screen.
 */
$router->addRoute('hello', function() {
    echo 'Well, hello there!!';
});

/**
 * Run it!
 */
$router->run();

Run The Code

Save this code locally as index.php.
In your terminal navigate to the directory where you saved the script.
Start the built-in PHP web server: php -S localhost:1234
In your browser go to: http://localhost:1234/hello

Conclusion

I've touched on the very basics of routing, shared some routing examples from the PHP world, and built a extremely simple router. On a related note, I've started work on the router that will be used in the Analyze PHP framework. To keep up to speed on it, be sure to follow @AnalyzePHP on Twitter.

One last thing, be sure to checkout my newsletter! Each week I'll send you a great email filled with updates, great links, tips & tricks, and other non-dev randomness. If you're interested you can sign up by following this link.

I Want Scalar Objects in PHP

Matt Sparks — Wed, 18 Jul 2018 12:03:49 +0000

Originally Posted on DevelopmentMatt.com

Recently, I read an interesting article from Andrew Carter entitled Make PHP Great Again [cheap plug: this link was included in my most recent Newsletter]. In it Andrew brought up the topic of scalar objects. If you're not familiar with scalar objects, they represent a single value (integer, boolean, string, etc.) that you can perform operations on*. In PHP this could look something like:

$name = 'Matt';

var_dump($name->length()); // int(4)

* It's important to note that, as far as I've been able to ascertain, the context in which you use the term "scalar" is important. Different languages implement and define scalar differently.

Soon after scalar objects were brought to the forefront of my mind, I came across the following tweet:

// Detect dark theme var iframe = document.getElementById('tweet-1018966511388647429-620'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1018966511388647429&theme=dark" }

To which I replied:

// Detect dark theme var iframe = document.getElementById('tweet-1018971564287713281-488'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1018971564287713281&theme=dark" }

The Case For Scalar Objects in PHP

If you read Andrew's post he discusses how PHP's core functions are inconsistent. This topic isn't new:

PHP 8 is a great opportunity to cleanup these inconsistencies. Introducing scalar objects would provide a consistent API that would be more fluent and much more enjoyable to work with. Which of the following is more intuitive to you?

$hello = str_replace('Matt', 'Bob', 'Hello Matt!');

var_dump($hello); // Hello Bob!

$hello = 'Hello Matt!';

var_dump($hello->replace('Matt', 'Bob')); // Hello Bob!

I know this is a silly example, but doesn't the second bit of code just feel better?

Let's get scalar objects in PHP 8! Who's with me?!?

#ScalarIn8

Building a PHP Framework: Part 7 - The Container

Matt Sparks — Sun, 08 Jul 2018 21:52:29 +0000

Orginially Posted on DevelopmentMatt.com

Part 6 began our discussion of PHP containers. Today, I'll be going into greater detail of the subject and, along with that, I'll run down the work done so far on the Analyze container.

A huge debt of gratitude goes how to the folks behind the PHP League Container and others. I've learned a ton studying their code.

A Quick Recap

What are containers and why do we use them? A container is both a registry composed of objects and a mechanism for retrieving them. It's the library and the librarian, so to speak. Containers provide developers a tool to more easily manage dependencies.

The Analyze Container

Work has begun on the container that will be used in the Analyze framework and, as of this writing, the foundation is essentially complete. Keep in mind that it's not finished, but it is far enough along to discuss it.

All of the code for the container can be found on Github.

A Simple Example

Currently, there are two ways to register an object with the container. The first is by using a factory. A factory uses a Closure to build the object upon retrieval.

$container = new Container;

$container->addFactory('Carbon', function () {
    return new \Carbon\Carbon;
});

$carbon = $container->get('Carbon');

var_dump($carbon->year) // 2018

The second option is to register a class using it's fully qualified name.

$container = new Container;

$container->addClass('Carbon', '\Carbon\Carbon');

$carbon = $container->get('Carbon');

var_dump($carbon->year) // 2018

Both methods take an alias as their first parameter.

How The Container Works

At its most basic core, the container is simply an object with a parameter – an array – that holds object definitions. When we ask for a dependency (get('Carbon')), the container looks for it in that array. If it's found, the object is built and returned. If not, an exception is thrown. Specifically, a NotFoundException exception.

<?php 

[...]

class Container implements ContainerInterface
{

    /**
     * Definitions
     * @var array
     */
    private $definitions = [];

    [...]

    /**
     * Get
     *
     * Returns the passed alias.
     *
     * @param  string $id
     * @return mixed
     * @throws NotFoundException
     */
    public function get($id)
    {
        if (!$this->has($id)) {
            throw new NotFoundException(sprintf('%s is not defined.', $id));
        }

        $definition = $this->definitions[$id];
        $definition->addArguments($this->arguments);

        return $definition->build();
    }

    [...]

}

Definitions

Definitions are the most important aspect of the container. They define how to build objects and without that functionality there's no use having a container. Each definition must implement the DefinitionInterface.

interface DefinitionInterface
{
    /**
     * Build
     *
     * @return object
     */
    public function build();
}

That means, each definition must have a build method that returns an object.

Each definition should, but aren't technically required to, extend the AbstractDefinition class.

abstract class AbstractDefinition implements DefinitionInterface
{
    /**
     * Arguments
     * @var array
     */
    public $arguments = [];

    /**
     * Add Arguments
     *
     * @param array $args
     */
    public function addArguments(array $args) : void
    {
        $this->arguments = $args;
    }

    /**
     * Has Arguments
     *
     * @return bool
     */
    public function hasArguments() : bool
    {
        return count($this->arguments) > 0;
    }
}

This class provides properties and methods that are used across definitions.

class FactoryDefinition extends AbstractDefinition
{
    /**
     * Callback
     * @var Closure
     */
    private $callback;

    /**
     * Constructor
     *
     * @param Closure $callback
     */
    public function __construct(Closure $callback)
    {
        $this->callback = $callback;
    }

    /**
     * Build
     *
     * @return object
     */
    public function build()
    {
        return call_user_func_array($this->callback, $this->arguments);
    }
}

class ClassDefinition extends AbstractDefinition
{
    /**
     * Concrete
     * @var string
     */
    private $concrete;

    /**
     * Constructor
     *
     * @param string $concrete
     */
    public function __construct(string $concrete)
    {
        $this->concrete = $concrete;
    }

    /**
     * Build
     *
     * @return object
     */
    public function build()
    {
        if ($this->hasArguments()) {
            $reflection = new ReflectionClass($this->concrete);

            return $reflection->newInstanceArgs($this->arguments);
        }

        return new $this->concrete;
    }
}

As you can see, both types of definition describe how to build an object.

Arguments

I'm sure you've noticed in the code above that arguments can be used when building an object. For example, let's say you can to pass a date and time when building a Carbon instance. Here's what that would look like:

$container->withArguments(['2010-05-16 22:40:10'])->get('Carbon');

What's Left to do

There's still quite a bit of work to be done on the container, but I'm pretty happy with where things are. The most pressing features left are implementing a SetterDefinition and, related to that, the ability to call methods. I'll also be using reflection to automatically inject dependencies. I'm not entirely sure how that's going to look, but I'm excited to get started on it.

Feedback

I'd love to hear from you. If you have suggestions or whatever else, hit me up on my Twitter machine.

PHP Reflection

Matt Sparks — Wed, 27 Jun 2018 22:22:25 +0000

Originally posted on DevelopmentMatt.

Beginning work on the Analyze PHP framework, specifically the container, brought reflection to my awareness. Before that I had maybe heard the term, but I definitely hadn't used it intentionally. Although it sounds like a scary computer science concept, it's not. It's actually quite simple:

Reflection is the ability of a computer program to examine, introspect, and modify its own structure...

That's it. (Thanks, Wikipedia)

Reflection in PHP

PHP provides a complete reflection API and multiple functions right out of the box. This provides an object the ability to examine itself and report back things like its methods and properties. With that functionality, we can automatically create documentation, inject dependencies, and a lot more.

It's possible that you have used reflection and didn't realize it. If you've ever used the get_class() or method_exists() functions, you've used reflection.
Examples of PHP Reflection

Here's the class we'll be working with:

<?php
namespace Springfield\Characters;

class Simpson
{
    private $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }

    public function getName() : string
    {
        return $this->name;
    }
}

To start off, let's use some of PHP's built in functions to print out information about the class. First, we'll print out the class methods.

$homer = new Simpson('Homer');

var_dump(get_class_methods($homer));

// array(2) { [0]=> string(11) "__construct" [1]=> string(7) "getName" }

Next, let's just get the name of the class.

$homer = new Simpson('Homer');

var_dump(get_class($homer));

// Springfield\Characters\Simpson

As I mentioned above, PHP provides a complete API. The PHP Reflection class provides us with a lot of powerful tools to inspect our objects. Using the class is simple, just instantiate the class passing along the object you'd like to inspect. Like so:

$reflection = new \ReflectionClass($homer);

Now you can get the class' properties:

var_dump($reflection->getProperties());

// array(1) { [0]=> object(ReflectionProperty)#3 (2) { ["name"]=> string(4) "name" ["class"]=> string(30) "Springfield\Characters\Simpson"  }

Or get the constructor and learn about its parameters:

$constructor = $reflection->getConstructor();

var_dump($constructor->getParameters());

// array(1) { [0]=> object(ReflectionParameter)#4 (1) { ["name"]=> string(4) "name" } }

Conclusion

While you may not use reflection daily, there are times it can come in very handy – working with other people's code, for example. I encourage you to checkout the links in the Further Reading section below to learn more.

Building a PHP Framework: Part 6 - Dependency Inversion, Inversion of Control, oh my!

Matt Sparks — Thu, 07 Jun 2018 23:12:41 +0000

Part 5 of this series discussed test driven development (TDD). Today, I'll be talking about Dependency Inversion, Inversion of Control, Dependency Injection, and other related topics.

What is Dependency Injection?

We'll start with Dependency Injection since it will lead us into our other topics. Wikipedia tells us that:

In software engineering, dependency injection is a technique whereby one object (or static method) supplies the dependencies of another object.

Have you ever wrote code similar to this:

<?php

class Superhero 
{
    public $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

class ComicBook
{
    public $mainCharacter;

    public function __construct(Superhero $superhero) 
    {
        $this->mainCharacter = $superhero;
    }
}

$superhero = new Superhero('Caffeine Man');
$comic = new ComicBook($superhero);

That's Dependency Injection in action. Our ComicBook object depends on our Superhero object so we inject it. Get it?

What is Dependency Inversion?

Comic books aren't always about superheroes. What if we wanted a comic book whose main character was a dog or a vampire or a vampiric dog? Let's re-write our code to allow any type of character to be used.

<?php

interface CharacterInterface
{
    /**
     * All classes implementing this interface must provide a getName method.
     */
    public function getName() : string;
}

abstract class Character implements CharacterInterface
{
    public $name;

    public function getName() : string
    {
        return $this->name;
    }
}

class Superhero extends Character
{
    public $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

class VampiricDog extends Character
{
    public $name;

    public function __construct(string $name)
    {
        $this->name = $name;
    }
}

class ComicBook
{
    public $mainCharacter;

    public function __construct(CharacterInterface $character)
    {
        $this->mainCharacter = $character;
    }
}

$superhero = new Superhero('Caffeine Man');
$superheroComic = new ComicBook($superhero);

var_dump($superheroComic->mainCharacter->getName());

$vampireDog = new VampiricDog('Mr. Fangz');
$vampireComic = new ComicBook($vampireDog);

var_dump($vampireComic->mainCharacter->getName());

Because we're coding to an interface we can now create any type of character for use in a comic book. We've completely decoupled our character implementation from our comic book implementation. Think about it – a comic book just wants to be a comic book and to do comic book things. It doesn't care what kind of character you give it, it just knows it needs one. Once the character is in place the comic book can get back to doing the work of a comic book. In other words:

A. High-level modules [ComicBook ] should not depend on low-level modules [Superhero ]. Both should depend on abstractions [CharacterInterface ].
B. Abstractions should not depend on details. Details should depend on abstractions.

What is Inversion of Control (IoC)?

Inversion of Control is sometimes referred to as "Hollywood's Law." As in, "don't call us, we'll call you." Brett Schuchert uses the game Monopoly to explain the concept:

Imagine the Monopoly system created with a number of players. The game orchestrates interaction between players. When it's time to have a player take a turn, the game might ask the player if it has any pre-movement actions such as selling houses or hotels, then the game will move the player based on the roll of the dice (in the real world, a physical player rolls dice and moves his or her token, but that's an artifact of the board game not being a computer - that is, it's a phenomenological description of what's going on rather than an ontological description). Notice that the game knows when a player can make decisions and prompts the player accordingly, rather than the player making the decision.

In traditional procedural programming steps are taken one after the other (do this, then do this, then do this). When a human takes a turn in Monopoly, they're in control:

Buy hotel.
Roll dice.
Move to new spot.

If a computer were in control of the game it would look more like:

Computer: Would you like to make a purchase? 
Human: I would like to buy a hotel. 
Computer: Great, here's your hotel. Do you want to make additional purchases? Human: No. 
Computer: Please roll the dice and move to a new spot.

The flow of the game is completely inverted.

What is an IoC Container?

An IoC Container is a bit of a misnomer. A better and more accurate name is Dependency Injection Container (DiC). The two terms get used interchangeably all the time. Regardless, a DiC is responsible for managing objects – from how they're created to how they're configured. Frameworks use containers to inject dependencies at run-time.

What Does This Have to do With a Framework?

A lot, actually. When you use a framework you're essentially giving it control of your application. Additionally, IoC/DiC containers lay the foundation for most frameworks. I've begun work on the Analyze container, feel free to keep up with the progress on Github. Once it's finished I'm going to do a deep dive into how it works and does what it does.

How to Use PHP Traits

Matt Sparks — Thu, 31 May 2018 23:33:43 +0000

PHP Traits are a great tool for code reuse. They allow developers to write methods that can be used in any number of classes, keeping your code DRY and more maintainable.

Define a PHP Trait

Traits are defined much in the same way as classes.

<?php

trait RobotSkillz
{
    public function speak(string $output)
    {
        echo $output;
    }
}

You'll notice that we're declaring a trait rather than a class.

A PHP Trait Example

Let's pretend we have a large number of classes related to film genres. Each class has public properties that we would like to return as either an array or JSON.

class HorrorFilm
{
    public $genre;
    public $length;
    public $rating;
    public $releaseDate;
    public $title;

    public function getGenre() : string
    {
        return $this->genre;
    }

    public function getLength() : int
    {
        return $this->length;
    }

    public function getRating() : string
    {
        return $this->rating;
    }
    public function getReleaseDate() : string
    {
        return $this->releaseDate;
    }

    public function getTitle() : string
    {
        return $this->title;
    }

    public function setGenre(string $genre)
    {
        $this->genre = $genre;
    }

    public function setLength(int $minutes)
    {
        $this->length = $minutes;
    }

    public function setRating(string $rating)
    {
        $this->rating = $rating;
    }

    public function setReleaseDate(string $date)
    {
        $this->releaseDate = $date;
    }

    public function setTitle(string $title)
    {
        $this->title = $title;
    }
}

Now, we'll create a trait that adds the methods we need and can be reused across all of our classes.

trait ArrayOrJson
{
    public function asArray() : array
    {
        return get_object_vars($this);
    }

    public function asJson() : string
    {
        return json_encode($this->asArray());
    }
}

We add this trait to our class:

class HorrorFilm
{
    use ArrayOrJson;

    ...

Putting it all together:

$film = new HorrorFilm;
$film->setTitle('Kill All Humans!');
$film->setGenre('Slasher');
$film->setLength(124);
$film->setRating('R');
$film->setReleaseDate('November 2, 2019');

var_dump($film->asArray());
var_dump($film->asJson());

Output:

array(5) { ["genre"]=> string(7) "Slasher" ["length"]=> int(124) ["rating"]=> string(1) "R" ["releaseDate"]=> 

string(16) "November 2, 2019" ["title"]=> string(16) "Kill All Humans!" } string(105) "{"genre":"Slasher","length":124,"rating":"R","releaseDate":"November 2, 2019","title":"Kill All Humans!"}"

Originally Posted on DevelopmentMatt

Forem: Matt Sparks

🧠 Learn! 5 Github Repos With Great Free & Open Source Resources

Free Books!

EbookFoundation / free-programming-books

📚 Freely available programming books

List of Free Learning Resources In Many Languages

Intro

How To Contribute

How to Share

Books

Other Languages

Open Source Documents

44bits / awesome-opensource-documents

📘 A curated list of awesome open source or open source licensed documents, guides, books.

Awesome Open Source Documents

Document Template

Table of Contents

Subjects

Computer Science

Build Your Own X

danistefanovic / build-your-own-x

🤓 Build your own (insert technology here)

Table of contents

Tutorials

Build your own 3D Renderer

Awesome Tools For Junior Devs

stephhappens / awesome-tools-for-junior-developers

A curated list of popular tools, tips and tricks for aspiring developers.

Awesome list of tools you might need on your path to senior developer-dom

Index

Tutorials

CS Video Courses

Developer-Y / cs-video-courses

List of Computer Science courses with video lectures.

Computer Science courses with video lectures

Table of Contents

Courses

Introduction to Computer Science

More!

Get What You Want: Using PHP Collections to easily filter and manipulate data. 😎

tightenco / collect

A Collections-only split from Laravel's Illuminate Support

Collect - Illuminate Collections

Installation

Development

A Simple Example

Getting Started

Collection Methods

.map()

.filter()

.sum()

.count()

Further Reading

Tips For Landing Your First Web Development Job

Technical

Understand Git/version control

Show Your Work

Research The Company

Continue to Learn

Non-Technical

Be Yourself

Try to Relax

Quick JavaScript Tip: the some() method

Yet Another Resources List!

API Related

Blogs/News

Error/Bug Tracking

Git/Deployment/Continuous Development

JavaScript

Newsletters

Planning/Notes

Random

Reference

RegEx

Text Editors

Video Tutorials

Some Awesome Dev Folks on Twitter

I've been coding for 20 years, Ask Me Anything!

Building a PHP Framework: Part 8 - Routing

How Routing Works

Build your own `3D Renderer`

`.map()`

`.filter()`

`.sum()`

`.count()`