Intellectual Property Is Neither Intellectual, Nor Property: Discuss

Well over a decade ago I tried to explain why things like copyright and patents (and especially trademarks) should not be considered "intellectual property," and that focusing on the use of "property" helped to distort nearly every policy debate about those tools. This was especially true among the crowd who consider themselves "free market supporters" or, worse, "against government regulations and handouts." It seemed odd to me that many people in that camp strongly supported both copyright and patents, mainly by pretending they were regular property, while ignoring that both copyrights and patents are literally centralized government regulations that involve handing a monopoly right to a private entity to prevent competition. But supporters seemed to be able to whitewash that, so long as they could insist that these things were "property", contorting themselves into believing that these government handouts were somehow a part of the free market.

For years I got strong pushback from people when I argued that copyright and patents were not property — and a few years ago, I modified my position only slightly. I pointed out that the copyright or the patent itself can be considered property (that is, the "right" that is given out by the government), but not the underlying expression or invention that those rights protect. Indeed, these days I think so much of the confusion about the question of "property", when it comes to copyright and patents, is that so many people (myself included at times) conflate the rights given by the government with the underlying expression or invention that those rights protect. In other words, the government-granted monopoly over a sound recording does have many aspects that are property-like. But the underlying song does not have many property-like aspects.

Either way, it’s great to see the Niskanen Center, a DC-think tank that continually does good work on a variety of subjects, has decided to try to re-climb that mountain to explain to "free market" and "property rights" supporters why "intellectual property is not property." If you’ve been reading Techdirt for any length of time, most of the arguments won’t surprise you. However, it is a very thoughtful and detailed paper that is worth reading.

Imagine two farms sitting side by side in an otherwise virgin wilderness, each of them homesteaded by a husband-and-wife couple (let’s call them Fred and Wilma and Barney and Betty) — two parcels of newly created private property appropriated from the commons by productive labor. One day, as Fred and Wilma are both working outside, they both notice Betty walking through the orchard of apple trees that Barney and she had planted some years back and which are now just ready to bear fruit for the first time. As Betty picks some of the first ripening apples to use in baking a pie, she sings an enchantingly lovely ballad that she and Barney had made up together back when they were courting. For the rest of the day Wilma can’t stop thinking about that beautiful song, while Fred can’t stop thinking about those trees full of delicious apples. That night Wilma sings the song to her baby daughter as a lullaby. Fred, meanwhile, sneaks over onto Barney and Betty’s property, picks a sack full of apples, tiptoes back to his property and proceeds to eat the lot of them, feeding the cores to his pigs before heading back inside.

Do you think that Fred and Wilma both did something wrong? Are they both thieves? Did both of them violate Barney and Betty’s rights? After all, Fred stole their apples, and Wilma “stole” their song — that is, she sang it to someone else without asking for permission. If you’re having trouble seeing Fred and Wilma’s actions as morally equivalent, it’s because of a fundamental difference between the two types of “property” they took from Barney and Betty.

That fundamental difference is that Barney and Betty’s song, like all ideal objects, is a nonrivalrous good. In other words, one person’s use or consumption of it in no way diminishes the ability of others to use or consume it. As expressed with characteristic eloquence by Thomas Jefferson (who perhaps not coincidentally viewed patents and copyrights with skepticism), the “peculiar character [of an idea] is that no one possesses the less, because every other possesses the whole of it. He who receives an idea from me, receives instruction himself without lessening mine; as he who lights his taper at mine, receives light without darkening me.”

By contrast, physical objects like apples are rivalrous: Once Fred and his pigs had finished devouring the ones Fred stole, they were gone and nobody else could consume them. Even when physical objects aren’t physically consumed by their owners — think paintings or plots of land — there is still unavoidable rivalry in using, enjoying, and disposing of them. The owner exercises that control over the owned object, and therefore nobody else does.

This is why it’s clear that Fred inflicted harm on his neighbors, since he took the fruit that they grew and now they don’t have it anymore. But Barney and Betty still have their song; the fact that Wilma sang it did nothing to prevent them from singing it anytime they want to. So, if Wilma did harm to Barney and Betty, what exactly is it?

The whole paper is really worth reading, and digs in on how and why people create, the nature of externalities in the creative process, and what actual data shows on the incentives of copyright and patents in driving innovation and creativity. The paper also digs deep on how excessive monopoly rights vastly hinder follow-on creativity and innovation (which is how most innovation and creativity come about in the first place).

In the case of copyright, excessive internalization is an impediment to the process of borrowing that is essential for the growth of creative works. While each artist may contribute new ideas to the cultural landscape, their contributions are based on the previous body of work. We all begin as consumers of ideas — and then some of us go on to create new ones. Take the case of Star Wars. The Jedi, Darth Vader, and the Death Star were all new in 1977, but George Lucas relied heavily on older ideas to make them possible. It is common knowledge that Lucas borrowed from Joseph Campbell’s Hero With a Thousand Faces when crafting the hero’s journey of Luke Skywalker. But the borrowing didn’t stop there. The famous opening crawl is virtually identical to those at the beginning of episodes of Flash Gordon Conquers the Universe. Telling the story from the perspective of two lowly characters, the droids R2-D2 and C-3P0, was inspired by Kurosawa’s The Hidden Fortress — something Lucas freely admits.

But while Lucas’s borrowing was permissible under copyright law, other borrowing is not, as current law gives rights holders control over broadly defined “derivative works.” A number of Star Wars fan films have been shuttered or severely limited in their scope (mostly by prohibiting commercialization) due to threats of litigation by Disney. The genre of fan fiction is a legal gray area, with many tests to determine whether it constitutes fair use, including commercialization and how “transformative” the work is. While the vast majority of these works will never amount to much, their existence is more tolerated than established as a clear-cut case of fair use. A more aggressively enforced copyright regime would almost certainly be the end of most fan fiction.

Thankfully, the paper also takes on the "fruits of our labor" view of both copyright and patents and why that doesn’t make much sense either.

The idea that people should be able to enjoy the fruits of their labor has clear intuitive appeal, but its invocation as a justification for stopping other people from making use of your ideas without your permission suffers a fatal difficulty: The argument proves far too much. Indeed, the problem goes beyond the widely understood “negative space” of intellectual creations that stand outside of patent and copyright protection: scientific discoveries, fashion, comedy, etc. Given that every new business venture starts with an idea, why shouldn’t every first entrant in a new industry be able to claim a monopoly? Or, for that matter, why not every first entry in a geographic market? If someone has the bright idea that their hometown needs a Thai restaurant and succeeds in making a go of it, why shouldn’t she be able to prevent competitors from coming in to poach her good idea — at least for a couple of decades? On the other hand, given that every new idea is in some way adapted from earlier ideas, why shouldn’t those first entrants in new industries and new markets be seen as “thieves” and “pirates” who are infringing on earlier ideas? Once you really start working through the implications, the whole argument collapses in a hopeless muddle.

The problem is this: The claim that enjoying the fruits of one’s intellectual labor entitles you to stop competitors has no inherent limiting principle, and thus the claim can be extended headlong into absurdity — as indeed it frequently has been. Of course, one can impose limits on the claim, but those limits have to be based on other principles — in particular, some sense of relative costs and benefits. But now we’re doing policy analysis and the case-specific comparison of costs and benefits, at which point the grandiose-sounding claim that patent and copyright law combat injustice shrivels and fades.

The paper then suggests some reforms for both copyright and patent law that seem quite reasonable. On copyright, they suggest reducing terms, requiring registration, limiting infringement to commercial exploitation, expanding fair use, narrowing derivative works, and ending anti-circumvention (a la DMCA 1201). These are all good suggestions, though the "commercial exploitation" one is one that sounds good but is often hard to implement, because what is and what is not "commercial exploitation" can be somewhat gray and fuzzy at times. But the intent here is sound.

On patents, the paper suggestions are to eliminate both software and business method patents, greatly tighten eligibility requirements, and no infringement in cases of independent invention. To me, as I’ve argued, the independent invention point is the most important. Indeed, I’ve argued that we should go further than just saying that independent invention is a defense against infringement. Instead, we should note that independent invention is a sign of obviousness, meaning not only that the second invention isn’t infringing, but that the initial patent itself should likely be invalid, as patents are only supposed to be granted if the idea is not obvious to those skilled in the art.

All in all, this is a great and thorough paper, especially for those who really want to insist that copyrights and patents should be treated like traditional property, and position themselves as supporters of "free markets." I fully expect — as I’ve experienced in the past — that those people will not engage seriously with these arguments and will rage and scream about them, but it’s still important to make these points.

Permalink | Comments | Email This Story

via Techdirt
Intellectual Property Is Neither Intellectual, Nor Property: Discuss

Track successful email deliveries, clicks and opens in your Laravel PHP application with Mailgun

Posted on Sep 9, 2019.

Table Of Contents

Source if you want to download the final project

While building ContestKit there was a feature I wanted to allow users to know if the emails that were sent to the winners were delivered successfully. Thankfully this feature is relatively easy to add because of Mailgun’s amazing API. Let’s create a new Laravel application and get started.

Set up your Laravel Application

To get this process started I always use the Laravel installer to start with a fresh install. (I will be using 6.0.1 which is the most recent at the time of this writing) This will get a Laravel application installed, generate your .env file and install your composer dependencies. Once that is installed we’re going to install the Laravel UI package to quickly scaffold the auth views for our app. This will generate our login and registration views.

composer require laravel/ui

Once that is installed run

php artisan ui vue --auth

Set up Mailgun

Next, you’ll need a Mailgun account. If you don’t have one, you can sign up for a free account here that gives you 10,000 free email sends a month. Once you have created your account. Once you have your account all set up, head over here to get your API information. You’re going to need your Private API key and the domain. Once you have that, open your .env and let’s add some information so our application knows to use Mailgun as our mail provider.

MAIL_DRIVER=mailgun MAILGUN_DOMAIN=yoursendingdomain.com MAILGUN_SECRET=private-api-key

Since we’re going to be using Mailgun as our email driver, we need to make sure we satisfy all the driver prerequisites, in this case, we need to install Guzzle Http so run

composer require guzzlehttp/guzzle.

We’re going to need to come back to Mailgun, later on, to set up some webhooks, but until then let’s get our application sending some emails, creating database records corresponding to the emails sent and get the controllers to handle the incoming webhook information from Mailgun.

Set up our database

Next, let’s get our email message model set up. In your console, run the following command.

$ php artisan make:model Message -m

This command will make a model for you in App/Model call Message.php and it will also make a migration for a table called messages. Let’s open our migration and get our DB schema in. The migration should be called ${datatime-stamp}_create_messages_table.php.

<?php use Illuminate\Support\Facades\Schema; use Illuminate\Database\Schema\Blueprint; use Illuminate\Database\Migrations\Migration; class CreateMessagesTable extends Migration { /** * Run the migrations. * * @return void */ public function up() { Schema::create('messages', function (Blueprint $table) { $table->bigIncrements('id'); $table->string('message_id')->index(); $table->morphs('sender'); $table->dateTime('delivered_at')->nullable(); $table->dateTime('failed_at')->nullable(); $table->integer('opened')->default(0); $table->integer('clicked')->default(0); $table->timestamps(); }); } /** * Reverse the migrations. * * @return void */ public function down() { Schema::dropIfExists('messages'); } }

What this table is going to do is track the outbound email message for us. We’re going to use a sender morphTo relationship so that we can attach outbound messages to any model in our app that we want. This will translate into being able to attach the welcome email we send to the user we sent it to. The $table->morphs('sender'); will create two columns for us, a sender_type which will be represented by the model that sent the message, the second will be the sender_id which will represent the id of the Model.

From there we will store the unique id generated for the email message. Mailgun will send this message id when it sends webhook events. We ask Mailgun to notify us of four different events.

  • The successful delivery of a message.
  • Any clicks on links in the email (if there are any links).
  • Every time the email is opened for that email.
  • Any permanently failed deliveries.

This failed delivery event is triggered when Mailgun attempts to send the email several but the receiving email service does not accept it. This usually results from a fake/bad email or your email was blocked by the mail service you were sending it to.

Next, let’s add the message relationship to our App\User model. Open up that and add the following.

<?php namespace App; use App\Message; use Illuminate\Contracts\Auth\MustVerifyEmail; use Illuminate\Foundation\Auth\User as Authenticatable; use Illuminate\Notifications\Notifiable; class User extends Authenticatable { use Notifiable; /** * The attributes that are mass assignable. * * @var array */ protected $fillable = [ 'name', 'email', 'password', ]; /** * The attributes that should be hidden for arrays. * * @var array */ protected $hidden = [ 'password', 'remember_token', ]; /** * The attributes that should be cast to native types. * * @var array */ protected $casts = [ 'email_verified_at' => 'datetime', ]; public function message() { return $this->morphOne(Message::class, 'sender'); } }

This will allow us to attach the outbound message on the user.

Next, let’s define the inverse relationship on the App\Message model.

<?php namespace App; use Illuminate\Database\Eloquent\Model; class Message extends Model { protected $guarded = ['id']; protected $dates = [ 'delivered_at', 'failed_at', ]; public function sender() { return $this->morphTo(); } }

Next, there is a great little tip/trick that you can do to help keep your database records for this sender_type column clean. Currently, if you create a record in your database using this relationship you’ll end up with a DB record that looks like this.

| id | message_id | sender_type | sender_id | delivered_at | failed_at | opened | clicked | created_at | updated_at | |----|--------------------------------------------------|-------------|-----------|--------------|-----------|--------|---------|---------------------|---------------------| | 1 | [email protected] | App\User | 1 | | | | | 2019-09-08 16:52:07 | 2019-09-08 16:52:07 |

You can see that the sender_type is the namespace of your User model. This is fine if you never change the namespace of your model, to clean this up, Laravel has a great Relation::morphMap([...]); method to help make the above a little more readable and a lot less coupled to our namespace.

open your AppServiceProvider.php file and in the register() method add the following.

<?php namespace App\Providers; use Illuminate\Database\Eloquent\Relations\Relation; use Illuminate\Support\ServiceProvider; class AppServiceProvider extends ServiceProvider { /** * Register any application services. * * @return void */ public function register() { Relation::morphMap([ 'users' => 'App\User', ]); } /** * Bootstrap any application services. * * @return void */ public function boot() { // } }

By doing the above, when you create a message now, your database record will look like this.

| id | message_id | sender_type | sender_id | delivered_at | failed_at | opened | clicked | created_at | updated_at | |----|--------------------------------------------------|-------------|-----------|--------------|-----------|--------|---------|---------------------|---------------------| | 1 | [email protected] | users | 1 | | | | | 2019-09-08 16:52:07 | 2019-09-08 16:52:07 |

Isn’t that SO MUCH better? If you want to read more about this, check out this post by Joseph Silber.

Set up our Mailgun webhook controller

All right, we’re ready to move on now. Now let’s make a controller for the webhooks. For this I like to namespace things to keep them organized. In your console enter the following.

$ php artisan make:controller Webhooks/MailgunWebhookController

Next, let’s make a middleware for this controller.

$ php artisan make:middleware MailgunWebhookMiddleware

ext, in your routes folder let’s make a webhooks.php file. In here we’re going to add all our webhook routes. I do this to keep things organized and because we want this URL to not have any of the web middleware stack. I also don’t want to have my webhook URL for Mailgun to be prefixed by /api otherwise you could put it in there as well.

In your newly created webhooks.php file add the following route.

Route::group(['namespace' => 'Webhooks',], function () { Route::post('mailgun', 'MailgunWebhookController'); });

If you were to run php artisan route:list you’ll notice the webhook URL you just added doesn’t come up, we’ll need to update our RouteServiceProvider.php to include the routes in this file. So let’s open that up. In the map() function let’s add a method called mapWebhookRoutes()

<?php namespace App\Providers; use Illuminate\Foundation\Support\Providers\RouteServiceProvider as ServiceProvider; use Illuminate\Support\Facades\Route; class RouteServiceProvider extends ServiceProvider { /** * This namespace is applied to your controller routes. * * In addition, it is set as the URL generator's root namespace. * * @var string */ protected $namespace = 'App\Http\Controllers'; /** * Define your route model bindings, pattern filters, etc. * * @return void */ public function boot() { // parent::boot(); } /** * Define the routes for the application. * * @return void */ public function map() { $this->mapApiRoutes(); $this->mapWebRoutes(); $this->mapWebhookRoutes(); } /** * Define the "web" routes for the application. * * These routes all receive session state, CSRF protection, etc. * * @return void */ protected function mapWebRoutes() { Route::middleware('web') ->namespace($this->namespace) ->group(base_path('routes/web.php')); } /** * Define the "api" routes for the application. * * These routes are typically stateless. * * @return void */ protected function mapApiRoutes() { Route::prefix('api') ->middleware('api') ->namespace($this->namespace) ->group(base_path('routes/api.php')); } /** * Define the "webhook" routes for the application. * * These routes are typically stateless. * * @return void */ protected function mapWebhookRoutes() { Route::prefix('webhooks') ->namespace($this->namespace) ->group(base_path('routes/webhooks.php')); } }

Okay now that we have our route, let’s get our controller set up. Open your MailgunWebhookController.php and let’s add an __invoke() method.

<?php namespace App\Http\Controllers\Webhooks; use App\Http\Controllers\Controller; class MailgunWebhookController extends Controller { public function __invoke() { // we'll handel our inbound webhook here. } }

Once you’ve done that let’s test to see if everything is working. if you run php artisan route:list you should see an output like this.

+--------+----------+----------------------------+------------------+------------------------------------------------------------------------+-------------------------------------------------+ | Domain | Method | URI | Name | Action | Middleware | +--------+----------+----------------------------+------------------+------------------------------------------------------------------------+-------------------------------------------------+ | | GET|HEAD | / | | Closure | web | | | POST | _ignition/execute-solution | | Facade\Ignition\Http\Controllers\ExecuteSolutionController | Facade\Ignition\Http\Middleware\IgnitionEnabled | | | GET|HEAD | _ignition/health-check | | Facade\Ignition\Http\Controllers\HealthCheckController | Facade\Ignition\Http\Middleware\IgnitionEnabled | | | GET|HEAD | _ignition/scripts/{script} | | Facade\Ignition\Http\Controllers\ScriptController | Facade\Ignition\Http\Middleware\IgnitionEnabled | | | POST | _ignition/share-report | | Facade\Ignition\Http\Controllers\ShareReportController | Facade\Ignition\Http\Middleware\IgnitionEnabled | | | GET|HEAD | _ignition/styles/{style} | | Facade\Ignition\Http\Controllers\StyleController | Facade\Ignition\Http\Middleware\IgnitionEnabled | | | GET|HEAD | api/user | | Closure | api,auth:api | | | GET|HEAD | home | home | App\Http\Controllers\[email protected] | web,auth | | | GET|HEAD | login | login | App\Http\Controllers\Auth\[email protected] | web,guest | | | POST | login | | App\Http\Controllers\Auth\[email protected] | web,guest | | | POST | logout | logout | App\Http\Controllers\Auth\[email protected] | web | | | POST | password/email | password.email | App\Http\Controllers\Auth\[email protected] | web,guest | | | GET|HEAD | password/reset | password.request | App\Http\Controllers\Auth\[email protected] | web,guest | | | POST | password/reset | password.update | App\Http\Controllers\Auth\[email protected] | web,guest | | | GET|HEAD | password/reset/{token} | password.reset | App\Http\Controllers\Auth\[email protected] | web,guest | | | POST | register | | App\Http\Controllers\Auth\[email protected] | web,guest | | | GET|HEAD | register | register | App\Http\Controllers\Auth\[email protected] | web,guest | | | POST | webhooks/mailgun | | App\Http\Controllers\Webhooks\MailgunWebhookController | | +--------+----------+----------------------------+------------------+------------------------------------------------------------------------+-------------------------------------------------+

Tip if you want to filter the results to a particular route pattern you can run this php artisan route:list --path=webhooks which will return any routes that match that pattern.

+--------+--------+------------------+------+--------------------------------------------------------+------------+ | Domain | Method | URI | Name | Action | Middleware | +--------+--------+------------------+------+--------------------------------------------------------+------------+ | | POST | webhooks/mailgun | | App\Http\Controllers\Webhooks\MailgunWebhookController | | +--------+--------+------------------+------+--------------------------------------------------------+------------+

Okay, If you got that then you’re golden. Next step let’s get an email that we can send. Let’s make a welcome email for users that register for our app. Since Laravel makes it dead simple to add auth login screens. In your console let’s run these commands. The first will create the auth boilerplate for us which will give us the login and registration pages in our app. Next, we will make a Mailable that we can send our users when they register, finally a listener where we will send that welcome email from.

The Welcome email

$ php artisan make:auth $ php artisan make:mail WelcomeEmail --markdown=emails.welcome $ php artisan make:listener SendWelcomeEmail

Once you’ve run that and you visit your app in the browser, you’ll notice that you now have a login and register nav item. Pretty awesome! Okay now open your EventServiceProvider.php file, in there you’ll notice that there are already events mapped out. let’s add our handler to that Registered event.

<?php namespace App\Providers; use App\Listeners\SendWelcomeEmail; use Illuminate\Auth\Events\Registered; use Illuminate\Auth\Listeners\SendEmailVerificationNotification; use Illuminate\Foundation\Support\Providers\EventServiceProvider as ServiceProvider; use Illuminate\Support\Facades\Event; class EventServiceProvider extends ServiceProvider { /** * The event listener mappings for the application. * * @var array */ protected $listen = [ Registered::class => [ SendWelcomeEmail::class, SendEmailVerificationNotification::class, ], ]; /** * Register any events for your application. * * @return void */ public function boot() { parent::boot(); // } }

Okay now that you have that done, every time someone registers in your app, this handler will be triggered. If you’re wondering what the SendEmailVerificationNotification class does, it’s used to send the verification email if you choose to require that in your application. You can learn more about that from here. let’s start sending emails to welcome our users! in the SendWelcomeEmail class add the following.

<?php namespace App\Listeners; use App\Mail\WelcomeEmail; use Illuminate\Auth\Events\Registered; use Illuminate\Contracts\Queue\ShouldQueue; use Illuminate\Queue\InteractsWithQueue; use Illuminate\Support\Facades\Mail; class SendWelcomeEmail { /** * Handle the event. * * @param object $event * @return void */ public function handle(Registered $event) { Mail::to($event->user)->send(new WelcomeEmail($event->user)); } }

So now, if you go ahead and register you should get an email sent to you that looks like this.

Welcome email example

This is the default markdown email that ships with Laravel if you see this, things are good. Now that we’re here, let’s start tracking the and saving the outbound messages. To do this we’ll open our App/Mail/WelcomeEmail.php

We’re going to want to add the following.

<?php namespace App\Mail; use App\User; use Illuminate\Bus\Queueable; use Illuminate\Contracts\Queue\ShouldQueue; use Illuminate\Mail\Mailable; use Illuminate\Queue\SerializesModels; class WelcomeEmail extends Mailable { use Queueable, SerializesModels; /** * Create a new message instance. * * @return void */ public function __construct(User $user) { $this->user = $user; } /** * Build the message. * * @return $this */ public function build() { $this->withSwiftMessage(function ($message) { $this->user->message()->create([ 'message_id' => $message->getId(), ]); }); return $this->markdown('emails.welcome'); } }

In the constructor of this class, we’re going to get passed the User that we’re sending this email to, we will be using this to store the outbound Message. The build() code is where we hook into the SwiftMailer to get the message-id and using the message relationship we create the message record in our database. So let’s try and register again and see what happens. Hopefully, you should see a record created in the messages table linked to the user you just registered? If so let’s move on to the webhooks handling.

Handling the incoming webhook

For this, we’ll need to head back into our Mailgun account. From the dashboard select the sending domain that you configured earlier on and then select the webhooks from the sidebar. I am running Laravel Valet locally so I’m going to run valet share and get a URL for my local app to use.

Configured webhooks in Mailgun

Once you’re done adding the 4 events we will be tracking, and yes there are more if you want to track more you’ll be able to add them with ease. So now that we have this let’s start updating our messages. The first thing we’re going to do is flesh out our middleware for our webhook controller. This middleware will ensure that the inbound HTTP request is in fact from Mailgun by verifying the webhook signature using our API key. Mailgun does refer to this as a webhook secret but if you look, you’ll notice that it’s the same token/string as your API key.

<?php namespace App\Http\Middleware; use Closure; use Illuminate\Http\Response; use Illuminate\Support\Facades\Log; /** * Validate Mailgun Webhooks * @see https://documentation.mailgun.com/user_manual.html#securing-webhooks */ class MailgunWebhook { /** * Handle an incoming request. * * @param \Illuminate\Http\Request $request * @param \Closure $next * @return mixed */ public function handle($request, Closure $next) { if (!$request->isMethod('post')) { abort(Response::HTTP_FORBIDDEN, 'Only POST requests are allowed.'); } if ($this->verify($request)) { return $next($request); } abort(Response::HTTP_FORBIDDEN); } /** * Build the signature from POST data * * @see https://documentation.mailgun.com/user_manual.html#securing-webhooks * @param $request The request object * @return string */ private function buildSignature($request) { return hash_hmac( 'sha256', sprintf('%s%s', $request->input('timestamp'), $request->input('token')), config('services.mailgun.secret') ); } public function verify($request) { $token = $request->input('signature.token'); $timestamp = $request->input('signature.timestamp'); $signature = $request->input('signature.signature'); if (abs(time() - $timestamp) > 15) { return false; } return hash_hmac('sha256', $timestamp . $token, config('services.mailgun.secret')) === $signature; } }

In the above, we take the inbound request and analyze it to ensure it’s authentic before allowing our controller to handle it. You can read more in the Mailgun docs. Below is an example of the payload you can expect from this webhook.

{ “signature”: { "timestamp": "1529006854", "token": "a8ce0edb2dd8301dee6c2405235584e45aa91d1e9f979f3de0", "signature": "d2271d12299f6592d9d44cd9d250f0704e4674c30d79d07c47a66f95ce71cf55" } “event-data”: { "event": "opened", "timestamp": 1529006854.329574, "id": "DACSsAdVSeGpLid7TN03WA", // ... }, "message": { "headers": { "message-id": "[email protected]", } } }

In the verify method you can see the three main things we have here, the timestamp, the token and the signature. What we need to do is concatenate the timestamp and token values, encode the resulting string with the HMAC algorithm (using your API Key as a key and SHA256 digest mode). Then we compare the result to the signature we in get the webhook payload. We also check if the timestamp is not too old which would make it stale. If everything looks good from here, we let this request through and we handle it in our controller.

<?php namespace App\Http\Controllers\Webhooks; use App\Http\Controllers\Controller; use App\Http\Middleware\Webhooks\MailgunWebhook; use App\Message; use Illuminate\Http\Request; class MailgunWebhookController extends Controller { /** * Constructor. */ public function __construct() { $this->middleware(MailgunWebhook::class); } /** * Handles the Stripe Webhook call. * * @param \Illuminate\Http\Request $request * * @return mixed */ public function __invoke(Request $request) { $data = $request->get('event-data'); $message_id = $data['message']['headers']['message-id']; if ($email = Message::whereMessageId($message_id)->first()) { if ($data['event'] === 'opened' || $data['event'] === 'clicked') { $email->increment($data['event']); } if ($data['event'] === 'delivered' || $data['event'] === 'failed') { $email->update(["{$data['event']}_at" => now()]); } } } }

In the construct method, we define the middleware we want to run to protect this controller, and in the __invoke() method we wrote before we will extract the data we need from the request. The message-id that we set in our messages table is found in message -> headers -> message-id this is id to retrieve the message record we want to update. Next we can find the event type (ie, clicked, opened, delivered, failed) in the event-data -> event, so now all we need to do is add some logic for opened or clicked events we’re going to increment a column, otherwise its a delivered or failed message so we’ll update those timestamps to the current UTC of the event. There you have it.

And there you have it, from here you can add messages to other models in your app, say invoices, or any other event that triggers an email and track if your user got it, opened it or clicked etc.

I hope you have found this useful! If you have any comments or things you think can improve this, send me a message or Tweet or something.. Bonus points if it’s a Drake gif.

Drizzy

via Laravel News Links
Track successful email deliveries, clicks and opens in your Laravel PHP application with Mailgun

Concealed Carry Practice: Where Should You Sit in This Photo and Why?

In an ever-increasingly violent world, situational awareness becomes your most important defense against attack. And it’s in your everyday concealed carry practice where the seemingly mundane decisions can have the most effect. Take a different route. Clear away the thick bushes by the window. And in public, put more thought into where you sit.

Much more than a handgun goes into completing a good Concealed Carry Rig.

RELATED STORY

Everything to Consider When Setting Up a Concealed Carry Rig

Take this photo from the U.S. Concealed Carry Association (USCCA) for example. Walk into a busy, crowded coffee shop or similar public setting, and there are a million little choices that impact are safety. But maybe no choice is quite as interesting as where one sits.

Concealed Carry Practice

Any student of the gun and certainly the old West knows the famous tales of Bill Hickok. Preoccupied with his poker hand, Hickok, for the reported first and only time, sat with his back to the door in Nuttal & Mann’s #10 Saloon in Deadwood, South Dakota. That’s when his assailant, forever known as “The Coward” Jack McCall, took advantage and quietly slipped in the door and executed Wild Bill in the back of the head. For our USCCA map, that would make most of the “3” seats pretty undesirable.

Since trouble is most likely to come through the front door, seating choice should reflect the location of the emergency exit along the opposite wall. The two bathrooms are close by, which could potentially offer refuge as well, and possibly a window as well. Table “A” gives quick access to both bathrooms, while tables “B” and “C” provide even quicker exits.

Table “I,” seats “1” and “4” offer the most tactical advantage. With the wall at one’s back, patrons have the most open field of view of the entire coffee shop. You can see both exits, and even the bathrooms. From table “I,” you can also see every other single customer, worker, etc. You’ve got it wired.

There’s a lot of choices to be made in everyday life. Giving them some thought, and thinking of your own capabilities and needs, provides the beginning of a plan. And it’s planning and being prepared that often help provide our best defense.

The post Concealed Carry Practice: Where Should You Sit in This Photo and Why? appeared first on Personal Defense World.

via Personal Defense World
Concealed Carry Practice: Where Should You Sit in This Photo and Why?

Clubhouse announces new collaboration tool and free version of its project management platform

Clubhouse — the software project management platform focused on team collaboration, workflow transparency and ease of integration — is taking another big step towards its goal of democratizing efficient software development.

Traditionally, legacy project management programs in software development can often appear like an engineer feeding frenzy around a clunky stack of to-dos. Engineers have limited clarity into the work being done by other members of their team or into project tasks that fall outside of their own silo.

Clubhouse has long been focused on easing the headaches of software development workflows by providing full visibility into the status of specific tasks, the work being done by all team members across a project, as well as higher-level project plans and goals. Clubhouse also offers easy integration with other development tools as well as its own API to better support the cross-functionality a new user may want.

Today, Clubhouse released a free version of its project management platform, that offers teams of up to 10 people unlimited access to the product’s full suite of features, as well as unlimited app integrations.

The company also announced it will be launching an engineer focused collaboration and documentation tool later this year, that will be fully integrated with the Clubhouse project management product. The new product dubbed “Clubhouse Write” is currently in beta, but will allow development teams to collaborate, organize and comment on project documentation in real-time, enabling further inter-team communication and a more open workflow.

The broader mission behind the Clubhouse Write tool and the core product’s free plan is to support more key functions in the development process for more people, ultimately making it easier for anyone to start dynamic and distributed software teams and ideate on projects.

write screenshot

“Clubhouse Write” Beta Version. Image via Clubhouse

In an interview with TechCrunch, Clubhouse also discussed how the offerings will provide key competitive positioning against larger incumbents in the software project management space. Clubhouse has long competed with Atlassian’s project management tool “Jira”, but now the company is doubling down by launching Clubhouse Write which will compete head-on with Atlassian’s team collaboration product Confluence.

According to recent Atlassian investor presentations, Jira and Confluence make up the lion’s share of the Atlassian’s business and revenues. And with Atlassian’s market capitalization of ~$30 billion, Clubhouse has its sights set on what it views as a significant market share opportunity.

According to Clubhouse, the company believes it’s in pole position to capture a serious chunk of Atlassian’s foothold given it designed its two products to have tighter integration than the legacy platforms, and since Clubhouse is essentially providing free versions of what many are already paying for to date.

And while Atlassian is far from the only competitor in the cluttered project management space, few if any competing platforms are offering a full project tool kit for free, according to the company. Clubhouse is also encouraged by the strong support it has received from the engineering community to date. In a previous interview with TechCrunch’s Danny Crichton, the company told TechCrunch it had reached at least 700 enterprise customers using the platform before hiring any sales reps, and users of the platform already include Nubank, Dataiku, and Atrium amongst thousands of others.

Clubhouse has ambitious plans to further expand its footprint, having raised $16 million to date through its Series A according to Crunchbase, with investments from a long list of Silicon Valley mainstays including Battery Ventures, Resolute Ventures, Lerer Hippeau, RRE Ventures, BoxGroup, and others.

A former CTO himself, Clubhouse cofounder and CEO Kurt Schrader is intimately familiar with the opacity in product development that frustrates engineers and complicates release schedules. Schrader and Clubhouse CMO Mitch Wainer believe Clubhouse can maintain its organic growth by that staying hyperfocused on designing for project managers and creating simple workflows that keep engineers happy. According to Schrader, the company ultimately wants to be the “default [destination] for modern software teams to plan and build software.”

“Clubhouse is the best software project management app in the world,” he said. “We want all teams to have access to a world-class tool from day one whether it’s a 5 or 5,000 person team.”


via TechCrunch
Clubhouse announces new collaboration tool and free version of its project management platform

As OSU tech licensing income climbs, newly hired commercialization chief sees ‘untapped potential’

Ohio State University’s licensing income from licensing research and staff innovations reached a new record of $8.8 million in 2019, even without the benefit of a one-time stock sale the prior year.
Kevin Taylor, the university’s new commercialization chief, echoed his predecessors in saying that’s not the number he’s focused on – because if he does his job right, the dollars will take care of themselves. Instead Ohio State focuses on leading indicators like the rise in the number of active spinoffs…

via Columbus Business News – Local Columbus News | Business First of Columbus
As OSU tech licensing income climbs, newly hired commercialization chief sees ‘untapped potential’

Top Fails That Hit Every Email Marketing Company

Email marketing, as you’ll know, is such a big part of modern-day business.

Mistakes and bumps occur frequently – this can be due to not copy checking, missing links, and various other editing bloopers.

Fails are frustrating for both ends of the emails – even if we all appreciate that, as humans, we all make errors sometimes.  

Mistakes and errors are great ways to learn – allowing you to overcome obstacles and create (nearly) perfect emails in the future.  

Below, we’ve listed the top fails that every email marketing company endures – and how they can overcome them.  

Dear First Name  

There’s really nothing quite as personal as receiving an email that says, “Dear </FirstName>.” 

Not only does this tell the user that they’re just a small tool in your marketing machine, but it’s also highly unprofessional.  

Email marketing is supposed to revolve around, making meaningful relationships with customers or clients. Sending out an email like this will push your audience away, making them feel like, well, a name on a list.  

The best way to stop issues like this happening is by sending out test emails. This way you can make sure that your HTML all works fine.  

Also, when you’re asking people to sign up to your mailing list, are you making it essential for them to give their names? Make sure there’s little margin for error or embarrassment. 

Spelling errors 

This is an inevitable part of any company that works with writing copy. Of course, certain typos and grammar mistakes are inescapable, especially if you’re sending out multiple emails a week.  

Double-check over your email copy, and make sure grammar is all up to standard. For example, an email from San Antonio read: 

“Help Kids Enjoy FREE beer” – one little comma changes the entire message that this email is trying to depict. Always check your emails, use tools like Grammarly to make sure you’re sending out an email that won’t become a viral tweet.  

Spell check might not always be your friend, too – autocorrect can make some embarrassing changes, so make sure it’s not changed anything without you noticing.  

Read over your email a few times before sending it out. That’s the key to a faultless campaign.  

If you aren’t ready to hire an in-house team of writers and editors, you can always take advantage of the available services and tools like Trust My Paper, Best Essay.Education, Grammarly, and Hemingway.

Segmenting your audience  

If you have a large mailing list, make sure that you’re segmenting your audience to an impeccable degree.  

You may remember when Amazon sent out a baby registry email to thousands of people with no babies or no babies on the way. That was a big blunder that caused a little bit of laughter.  

However, segmenting your audience wrongly can lead to some disasters. Certain audiences don’t want to receive certain emails, and it may push them to unsubscribe.  

In fact, the National Client Email Report from the DMA in 2015, stated that 77% of email marketing ROI came from segmented, targeted, and triggered campaigns.  

Make sure that customers or clients are updating their preferences, to stop them from clicking the unsubscribe button.  

The images don’t follow the rules 

Certain emails just don’t look the way you want them to, once you’ve sent them out.  

Various buttons and images will completely go rouge, and make your email look so strange.  

This actually has cataclysmic consequences – if your customer opens up the email, and sees a jumble of images and buttons, they won’t stay on it for long.  

Again, this can be solved with a simple test email being sent out to multiple different browsers and devices. This way, you can ensure that it all works the way you want it to.  

Don’t try to hide the unsubscribe button  

As an email marketing company, the unsubscribe button might feel like your worst enemy – but you should never try to hide the button.  

Every form of an electronic message is required to have an unsubscribe option, and it’s only fair.  

Firstly, you could end up getting in a lot of trouble, which is never desirable and doesn’t reflect well on your company.  

Secondly, if they can’t find your unsubscribe button, they might just choose to report your email for spam. When multiple people do this, it causes real problems.  

Just make sure it’s nice and obvious. If people want to unsubscribe, for whatever reason, they should be able to without any issues.  

Fonts not displaying correctly 

Email clients are very restrictive when it comes to what they may (or may not) render.  

It’s frustrating because there’s a wide range of beautiful fonts out there, but you can’t use them all with emails. Sometimes, it just isn’t worth the risk too.  

It all depends on the contact’s own device. This means it’s best if you stick to standard web fonts, so you can ensure they’re accessible to everybody.  

If the font you have used isn’t on the recipient’s device, it will fall back to a web standard font anyway. This can cause your design to look strange for some people. You don’t have any control over what this backup version looks like, unfortunately.  

“I strongly recommend that you always play it safe with fonts. The standard web fonts can make great emails, anyway. Don’t be disheartened if some obscure font you really like can’t be integrated or displayed in various email clients.” — Amanda Muller, an email marketing specialist at Grab My Essay.

Ineffective subject lines  

Did you know an average business worker receives and sends upwards of 121 emails every single day? 

There’s very little chance that they will open and read every single one. They will, however, see all the subject lines.  

If you have a cliché or boring subject line, they’ll delete without even opening.  

Writing headlines and subject lines is a tricky art to master. It’s absolutely essential, though. The subject line is the difference between an email that’s engaged with, and one that isn’t.  

Plan your subject lines carefully, and always make sure that you’re targeting the audience that you want to.  

Emojis are a great way to communicate in business, believe it or not. This is especially true if you’re targeting younger generations.  

Remember; what’s the problem you’re trying to solve or the main selling point? 

Offering no value  

On the same note, with so many emails being sent out every single day – you have to provide your audience with value.  

To begin, you have to build a relationship and create a level of trust with your subscribers. This will ensure that they will open your emails. 

For example, if you’re a travel website – make sure that you provide your audience with a mixture of valuable information and promotions. Top 10 travel tips, The best rucksacks for backpackers, and the cheapest hostels in Bali are all great pieces of information, that can all be used as selling points.  

Don’t give too much information, though. People don’t have the time or attention span to read through paragraphs of information. Make it short and sweet – with snappy, appealing links, and headlines. Give the power to the reader.  

Conclusion

With all these common mistakes and fails, it should all be seen as a learning curve.  

There are multiple ways that an email campaign can go wrong – but avoiding these top mistakes will ensure that it happens much less often.  

Failure doesn’t mean that you should give up. It simply means that you should keep climbing and learning. It’s a necessary part of creating the most successful email campaigns.  

What mistakes have you learned from? 


via Noupe
Top Fails That Hit Every Email Marketing Company

A little history for David Hogg and the Democrats on Wounded Knee

I saw Miguel’s post about David Hogg claiming that mass shootings today are somehow related to Wounded Knee and some Harvard level deep thinking like that.

David Hogg is part of the chorus of voices calling for civilian disarmament, which has metastasized thought the Democrats and is now part of every Presidential primary candidate’s platform.

From History.com:

On December 29, the U.S. Army’s 7th Cavalry surrounded a band of Ghost Dancers under Big Foot, a Lakota Sioux chief, near Wounded Knee Creek and demanded they surrender their weapons. As that was happening, a fight broke out between an Indian and a U.S. soldier and a shot was fired, although it’s unclear from which side. A brutal massacre followed, in which it’s estimated 150 Indians were killed (some historians put this number at twice as high), nearly half of them women and children. The cavalry lost 25 men.

From the Encyclopedia of the Great Plains published by the University of Nebraska-Lincoln:

While these discussions proceeded in the Lakota camp, a number of Indians began singing Ghost Dance songs, with some rising to throw handfuls of dirt in the air. The troops who surrounded them perceived the singing and dirt throwing as signals to attack, and at this tense moment the fuse was lit. A man named Black Coyote (sometimes called Black Fox) refused to surrender his rifle to a soldier. The two began wrestling over the gun, and in the struggle it discharged. Immediately the nervous troops began firing, while the Miniconjous retrieved their weapons and returned fire.

The military’s rifle fire was complemented with cannon rounds from Hotchkiss guns, whose accuracy and exploding shells were formidable. The outnumbered and outgunned Lakotas fled, and for several hours intermittent gunfire continued, with the military in pursuit. Bodies were found as far away as three miles from the camp. Firing ceased, and by midafternoon the troops had gathered up their dead and wounded, as well as Lakota wounded, and returned to Pine Ridge Agency. The fear of a reprisal attack kept troops and civilians entrenched at the agency until January 3, 1891, when a military-escorted civilian burial party proceeded to the site of the massacre. There they buried 146 Lakotas in a single mass grave. Other dead were accounted for later, bringing the total to more than 250 Lakotas; the Seventh Cavalry lost twenty-five men.

So the Wounded Knee Massacre was the result of the US Government engaging in civilian disarmament.

This horrible massacre, which is a stain on the history of the United States, was the 1890’s equivalent of what David Hogg has been demanding for over a year and the Democrats are campaigning on.

By Hogg’s current standard, the 7th Calvary are the heroes, taking the rapid-fire, high capacity magazine rifles away from civilians.

This just goes to prove that any disarmament program will be a blood bath, as all it takes for the shooting to start is for one man to refuse to give up his rifle and get into a tussle over it.  The idea that several million Americans could be disarmed peacefully is ludicrous if the US Calvary couldn’t peacefully disarm a few hundred Indians.

Maybe it’s because I didn’t go Harvard like David Hogg, but I just can’t follow the logic here.

 

 

via
A little history for David Hogg and the Democrats on Wounded Knee

KelTec Releases a New .22LR Option: The P17 Pistol

There have been talks over the years of a .22lr version of the KelTec PMR-30, and the P17 appears to be the answer. Following the normal KelTec naming convention, the P17 is a .22lr with 16+1 capacity. Out of the box, it comes with three magazines, adjustable fiber optic sights, Picatinny accessory rail, and a threaded barrel.

MSRP is $199.

Here’s what KelTec has to say about it:

If you’re in the market for a 17-round, compact .22LR pistol with more bells & whistles than a Christmas Day parade, then the P17 is definitely for you! Oh and with an MSRP of $199, you can’t afford to pass one up!

COMPACT
At less than 14-ounces fully loaded, and barely longer than a dollar bill, the P17 is concealable for pretty much anyone. Just don’t forget it’s there when you need it! The threaded barrel, Picatinny-style accessory rail, ambidextrous safety, ambidextrous magazine release and three (3) 16rd magazines come standard. That’s a ton of value added in such a small package. And did we mention the price?

ACCURATE
Don’t let the small size fool you. This little pistol is a tack driver. The excellent trigger, fiber optic front sight and adjustable rear sight help you extend the P17’s range. It’s a handy little .22LR that builds confidence and burns bull’s eyes.

VERSATILE
Every tool has a purpose and having the right tool for the job sets you up for success. Its size, weight, and caliber are the perfect combination for training that new shooter in your life. For more experienced shooters looking to hone their skills, the P17 is also a great training tool for when you’re on a budget.


Other specifications include:

CALIBER: .22LR
WEIGHT UNLOADED: 0.8lbs
MAGAZINE CAPACITY: 16
OVERALL LENGTH: 6.65″
BARREL LENGTH: 3.93″
BARREL THREADS: 1/2-28 TPI

For more information, you can visit KelTec online here.

via Recoil
KelTec Releases a New .22LR Option: The P17 Pistol

APIs are the next big SaaS wave

Daniel Levine
Contributor
Daniel Levine is a partner at Accel. He joined the firm in 2010 and focuses on product-first startups aimed at consumers, developers, and bottoms-up business users.

While the software revolution started out slowly, over the past few years it’s exploded and the fastest-growing segment to-date has been the shift towards software as a service or SaaS.

SaaS has dramatically lowered the intrinsic total cost of ownership for adopting software, solved scaling challenges and taken away the burden of issues with local hardware. In short, it has allowed a business to focus primarily on just that — its business — while simultaneously reducing the burden of IT operations.

Today, SaaS adoption is increasingly ubiquitous. According to IDG’s 2018 Cloud Computing Survey, 73% of organizations have at least one application or a portion of their computing infrastructure already in the cloud. While this software explosion has created a whole range of downstream impacts, it has also caused software developers to become more and more valuable.

The increasing value of developers has meant that, like traditional SaaS buyers before them, they also better intuit the value of their time and increasingly prefer businesses that can help alleviate the hassles of procurement, integration, management, and operations. Developer needs to address those hassles are specialized.

They are looking to deeply integrate products into their own applications and to do so, they need access to an Application Programming Interface, or API. Best practices for API onboarding include technical documentation, examples, and sandbox environments to test.

APIs tend to also offer metered billing upfront. For these and other reasons, APIs are a distinct subset of SaaS.

For fast-moving developers building on a global-scale, APIs are no longer a stop-gap to the future—they’re a critical part of their strategy. Why would you dedicate precious resources to recreating something in-house that’s done better elsewhere when you can instead focus your efforts on creating a differentiated product?

Thanks to this mindset shift, APIs are on track to create another SaaS-sized impact across all industries and at a much faster pace. By exposing often complex services as simplified code, API-first products are far more extensible, easier for customers to integrate into, and have the ability to foster a greater community around potential use cases.

Screen Shot 2019 09 06 at 10.40.51 AM

Graphics courtesy of Accel

Billion-dollar businesses building APIs

Whether you realize it or not, chances are that your favorite consumer and enterprise apps—Uber, Airbnb, PayPal, and countless more—have a number of third-party APIs and developer services running in the background. Just like most modern enterprises have invested in SaaS technologies for all the above reasons, many of today’s multi-billion dollar companies have built their businesses on the backs of these scalable developer services that let them abstract everything from SMS and email to payments, location-based data, search and more.

Simultaneously, the entrepreneurs behind these API-first companies like Twilio, Segment, Scale and many others are building sustainable, independent—and big—businesses.

Valued today at over $22 billion, Stripe is the biggest independent API-first company. Stripe took off because of its initial laser-focus on the developer experience setting up and taking payments. It was even initially known as /dev/payments!

Stripe spent extra time building the right, idiomatic SDKs for each language platform and beautiful documentation. But it wasn’t just those things, they rebuilt an entire business process around being API-first.

Companies using Stripe didn’t need to fill out a PDF and set up a separate merchant account before getting started. Once sign-up was complete, users could immediately test the API with a sandbox and integrate it directly into their application. Even pricing was different.

Stripe chose to simplify pricing dramatically by starting with a single, simple price for all cards and not breaking out cards by type even though the costs for AmEx cards versus Visa can differ. Stripe also did away with a monthly minimum fee that competitors had.

Many competitors used the monthly minimum to offset the high cost of support for new customers who weren’t necessarily processing payments yet. Stripe flipped that on its head. Developers integrate Stripe earlier than they integrated payments before, and while it costs Stripe a lot in setup and support costs, it pays off in brand and loyalty.

Checkr is another excellent example of an API-first company vastly simplifying a massive yet slow-moving industry. Very little had changed over the last few decades in how businesses ran background checks on their employees and contractors, involving manual paperwork and the help of 3rd party services that spent days verifying an individual.

Checkr’s API gives companies immediate access to a variety of disparate verification sources and allows these companies to plug Checkr into their existing on-boarding and HR workflows. It’s used today by more than 10,000 businesses including Uber, Instacart, Zenefits and more.

Like Checkr and Stripe, Plaid provides a similar value prop to applications in need of banking data and connections, abstracting away banking relationships and complexities brought upon by a lack of tech in a category dominated by hundred-year-old banks. Plaid has shown an incredible ramp these past three years, from closing a $12 million Series A in 2015 to reaching a valuation over $2.5 billion this year.

Today the company is fueling an entire generation of financial applications, all on the back of their well-built API.

Screen Shot 2019 09 06 at 10.41.02 AM

Graphics courtesy of Accel

Then and now

Accel’s first API investment was in Braintree, a mobile and web payment systems for e-commerce companies, in 2011. Braintree eventually sold to, and became an integral part of, PayPal as it spun out from eBay and grew to be worth more than $100 billion. Unsurprisingly, it was shortly thereafter that our team decided to it was time to go big on the category. By the end of 2014 we had led the Series As in Segment and Checkr and followed those investments with our first APX conference in 2015.

Plaid, Segment, Auth0, and Checkr had only raised Seed or Series A financings! And we are even more excited and bullish on the space. To convey just how much API-first businesses have grown in such a short period of time, we thought it would be useful perspective to share some metrics over the past five years, which we’ve broken out in the two visuals included above in this article.

While SaaS may have pioneered the idea that the best way to do business isn’t to actually build everything in-house, today we’re seeing APIs amplify this theme. At Accel, we firmly believe that APIs are the next big SaaS wave — having as much if not more impact as its predecessor thanks to developers at today’s fastest-growing startups and their preference for API-first products. We’ve actively continued to invest in the space (in companies like, Scale, mentioned above).

And much like how a robust ecosystem developed around SaaS, we believe that one will continue to develop around APIs. Given the amount of progress that has happened in just a few short years, Accel is hosting our second APX conference to once again bring together this remarkable community and continue to facilitate discussion and innovation.

Screen Shot 2019 09 06 at 10.41.10 AM

Graphics courtesy of Accel


via TechCrunch
APIs are the next big SaaS wave

Ohio universities take ‘big leap’ on tech commercialization with new ‘IP Promise’

Melissa Bailey joined Ohio State University’s optometry faculty in 2006, catching the entrepreneurial bug amid the school’s first efforts to amp up commercialization of research.
She spun out her first company, a mobile app to measure vision, in 2014 – a long licensing process "from scratch," the associate professor said. It also was tough to find internal funding to develop the product. Her second spinout in 2017 was bifocal soft contact lenses. OSU’s licensing process was streamlined and she…

via Columbus Business News – Local Columbus News | Business First of Columbus
Ohio universities take ‘big leap’ on tech commercialization with new ‘IP Promise’