In the latest tutorial posted to the SitePoint PHP blog author Wern Ancheta shows you how to integrate your application with the Microsoft Text Analytics API, a service offered by the company putting machine learning to work on things like keyword extraction, topic detection and language detection.

With the explosion of machine learning services in recent years, it has become easier than ever for developers to create “smart apps”. In this article, I’ll introduce you to Microsoft’s offering for providing machine-learning capabilities to apps. Specifically, you’ll learn about the Text Analytics API and build an app to enhance the understanding of online sellers when it comes to their customers.

The tutorial then introduces the Microsoft Cognitive Services API and, more specifically, the Text Analytics API that they'll be hooking the application in to. They walk you through getting an API key for the service, creating an "account" for the application you're working with and deploying it for immediate use. They introduce the functionality of the API with a few "play" examples of each API offered before getting into the creation of their sample application - a tool that reviews the contents of customer feedback, looking for key phrases and returns highlighted versions with what it sees as important.

Rob Allen has a post to his site announcing the latest release of the Slim Framework - v3.4.0 - and an update that allows for full PSR-7 support, telling Composer that the framework fully supports it now as well.

I've been neglecting Slim's PR queue recently, so this weekend I dedicated a lot of time to merging all the good work that our contributors have done. As a result, I'm delighted to release version 3.4.0! This release has a larger set of changes in it than I would have ideally liked which is a direct consequence of having gone two months between releases rather than one.

One particularly interesting addition that we have a made this release is adding a provide section to our composer.json file. [...] This means that we have informed Composer that Slim provides a valid implementation of the interfaces in psr/http-message-implementation virtual package that defines the PSR-7 interfaces.

This basically means that if you're using other libraries/tools that require a PSR-7 compatible system to work correctly, they'll detect that Slim fully supports it.

In a recent post to his site Rob Allen shows you how to create dependency injection factories for Slim (v3) controllers.

When using classes for route actions in Slim 3, I recommend using a single class for each route. However you can use a single class for multiple routes. To register a class method to a route you pass a string as the route callable where the class name is separate from method by a colon. Slim will retrieve MyController from the DI container and then call the listAction method using the usual signature. f you don't specify a method, then Slim will see if it treat the class as a callable, so you can implement __invoke() and then register the route.

He shows how to create a factory method as a part of the Slim container for a constructor and inject the correct dependencies. He shows how to register these dependencies as other factory methods inside the DI container and how to pull them back out for injection. He prefers this method as it reduces "hidden dependency" issues and makes the controllers themselves easier to test.

Joe Ferguson has a quick post to his site today showing you how to use a Homestead VM to run a Slim 3 application with just a few quick commands.

I’ve been a fan of SlimPHP for a really long time. Recently I started using it for a site that I do freelancing development for and wanted to share a quick solution to local development. It’s no secret that I love Laravel’s Homestead vagrant environment. Using the per-project installation method, you are only three commands away from running a SlimPHP skeleton application in a local Homestead VM.

The remainder of the post shows the commands to:

• create a new Slim application based on the Skeleton
• Setting up Homestead
• And creating a new instance to host the Slim application

With a quick vagrant up your virtual machine is ready to go with the application ready to run.

The Free the Geek podcast, hosted by Matthew Setter has posted their latest episode - Episode #14. This time Matthew is joined by Rob Allen to talk about "Slim 3, PSR-7, Constraints and Decisions"

In this episode I have a fireside chat with sagely Rob Allen, about being one of the leads on the Slim 3 project, and about the constraints and decisions developers need to make.

This was one of the best fireside chats I’ve had, because the advice resonated so deeply with me. Besides getting an inside glimpse into the Slim project, and what it’s like to be a maintainer on such a wildly popular and successful open source project; Rob shared with me the importance of other areas, besides the code, which we often are all so precious about.

You can listen to this latest episode either through the in-page audio player or by downloading the mp3 directly. If you enjoy the episode and want to catch more, be sure to subscribe to their feed or follow the show on Twitter to get updates as new episodes are released.

If you're a Slim framework user you should check out the latest post on Rob Allen's site covering all things configuration in using the framework and it's simple configuration handling.

Configuration in Slim Framework is nice and simple: the App's constructor takes a configuration array for the DI container.

He shows how to pass in the configuration as a optional constructor parameter on the main application, including a settings value containing some of the common options. These include the displayErrorDetails flag to show/hide detailed error messages and a logger setup (in his example Monolog). He also shows how to:

• get settings from the configuration
• use a separate file for the configuration
• using a .env configuration file
• combining multiple configuration files

He includes code examples for each of these cases as well as a method for using a non-array structure (like YAML or XML) via the ZendConfig component.

In this recent post to his site Rob Allen, a developer with the Slim framework project, covers some of the improvements around error handling in the latest version of the framework, v3.2.0.

We released Slim 3.2.0 yesterday which includes a number of minor bug fixes since 3.1.0 and also a few nice improvements around the way we handle errors.

He talks about the previous error handling (suppressing them in favor of a bland error page) and how v3.2.0 changes this by writing them to the error log by default. He also talks about changes around the addition of a PHP 7 error handler that works with the PHP 7 Error exception types and functions the same way as the default Exception handler.

In a post to his site Rob Allen explains how to handle file uploads in a PSR-7 structure, specifically illustrating with an example using the Slim (v3) framework.

Handling file uploads in Slim 3 is reasonably easy as it uses the PSR-7 Request object, so let's take a look.

He shows how to create a simple index route in a Slim application and render a view containing just a simple form with an upload field and submit button. When the form submits, he uses the getUploadedFiles method on the Slim Request object to get the file information for the upload. He also shows how to check for errors on the upload using the file data as an object and calling the getError method.

Rob Allen has a quick post sharing the results of a test run of the Phan static analysis tool on the current state of the Slim 3 framework codebase (with v3.0 just being released).

Having installed Phan, I decided to use it against the upcoming Slim 3 codebase.

Phan needs a list of files to scan, and the place I started was with Lorna's article on Generating a file list for Phan.

He walks through the steps for creating this list of files (removing developer dependencies) and the results from the Phan execution. While a good amount of the errors related more to dependencies and missing class/interface definitions, there were some typing errors found based on the difference between the docblock and how the code handled the variable.

The Slim Framework project has officially announced the release of the next major version of their popular microframework: Slim 3.0.0.:

We are delighted to release the first stable version of Slim 3, 3.0.0 following a series of release candidates. [...] Slim 3 is a major update with all parts of the framework updated.

New features in this major version release include:

• the change to a container-interop compatible dependency injection system
• complete PSR-7 support
• an update to internal classes to code against interfaces rather than concrete classes
• route callback binding to $this (the Container instance)

They've also gotten rid of some of the "cruft" that had built up over previous versions and slimmed down (pardon the pun) the codebase making it even simpler and more component driven. They've posted installation instructions to help you get started and a simple skeleton application you can drop in and be up and running quickly.