Once you have your Web API developed, before exposing it to your clients, based upon your needs you may need to secure some or all parts of your API Service so that only verified users can access your API service. This securing in ASP.NET can be achieved using the authentication and authorization mechanisms.
Authentication is the process of determining whether someone or something is, in fact, who or what it is claimed to be. By using the authentication mechanism, we make sure that every request received by the Web API service is sent from a client with proper credentials.
A message handler is a class that receives an HTTP request and returns an HTTP response. Message handlers are derived classes from the abstract class HttpMessageHandler. They are good for cross-cutting concerns that operate at the level of HTTP messages (rather than controller actions). For example, a message handler might:
In a Web API, typically, a series of message handlers are chained together, forming a pattern called delegating handler.

The order in which these handlers are set up is important as they will be executed sequentially.
The most important handler sits at the very top, guarding everything that comes in. If the checks pass, it will pass this request down the chain to the next delegating handler, and so on.
If all goes well, it will then arrive at the API Controller and execute the desired action. However, if any of the checks fail within the handlers, then the request is denied and a response is sent to the client.
With this much theory in hand, now let's write code for our handlers. We will create two message handlers in this article:
In your Web API project, create a folder called MessageHandlers and add a class APIKeyHandler.cs.
public class APIKeyHandler : DelegatingHandler
{
//set a default API key
private const string yourApiKey = "X-some-key";
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
bool isValidAPIKey = false;
IEnumerable<string> lsHeaders;
//Validate that the api key exists
var checkApiKeyExists = request.Headers.TryGetValues("API_KEY", out lsHeaders);
if (checkApiKeyExists)
{
if (lsHeaders.FirstOrDefault().Equals(yourApiKey))
{
isValidAPIKey = true;
}
}
//If the key is not valid, return an http status code.
if (!isValidAPIKey)
return request.CreateResponse(HttpStatusCode.Forbidden, "Bad API Key");
//Allow the request to process further down the pipeline
var response = await base.SendAsync(request, cancellationToken);
//Return the response back up the chain
return response;
}
}The APIKeyHandler.cs inherits from DelegatingHandler, which in turn inherits from HttpMessageHandler. This allows us to override the functionality for inspecting an HTTP request and control whether we want to allow this request to flow down the pipeline to the next handler and controller or halt the request by sending a custom response.
In this class, we are achieving this by overriding the SendAsync method. This method looks for an API key (API_KEY) in the header of every HTTP request, and passes the request to the controller only if a valid API key is present in the request header.
Now, to see this handler in action, we need to first register it to our application in the Application_Start method from the Global.asax file.
GlobalConfiguration.Configuration.MessageHandlers.Add(new APIKeyHandler());
Try calling any method that you have exposed through your Web API controllers and you should see "Bad API Key" as response.
For a demo in this article, I am using the same project and the URLs that I have created in my previous article, "Developing an ASP.NET Web API".
Let's verify that the APIKeyHandler is working alright by creating an HTTP Request with correct headers. For that, we need to create an HTTP header with key value:
"API_KEY" : "X-some-key"
I am using a Mozilla browser plugin called "HTTP Tool" for creating HTTP request headers here.
The HTTP request is now passed all the way to the controller by the handler.
So our API key check handler is in place now. This secures our Web API to make sure only those clients that are provided with valid API keys can access this service. Next we will look at how we can implement security based on user roles.
Basic authentication, as its name suggests, is the most simple and basic form of authenticating HTTP requests. The client sends Base64-encoded credentials in the Authorize header on every HTTP request, and only if the credentials are verified does the API return the expected response. Basic authentication doesn't require server-side session storage or implementation of cookies as every request is verified by the API.
Once basic authentication implementation in Web API is understood, it will be very easy to hook other forms of authentication. Only the authentication process will be different, and the Web API hooks, where it is done, will be the same.
For verifying user credentials, we create an IPrincipal object which represents the current security context.
Add a new folder called Security and a new class TestAPIPrincipal.cs in it.
public class TestAPIPrincipal : IPrincipal
{
//Constructor
public TestAPIPrincipal(string userName)
{
UserName = userName;
Identity = new GenericIdentity(userName);
}
public string UserName { get; set; }
public IIdentity Identity { get; set; }
public bool IsInRole(string role)
{
if (role.Equals("user"))
{
return true;
}
else
{
return false;
}
}
}The IIdentity object associated with the principal has a property called IsAuthenticated. If the user is authenticated, this property will return true; otherwise, it will return false.
Now, let's create another handler called AuthHandler.cs.
public class AuthHandler : DelegatingHandler
{
string _userName = "";
//Method to validate credentials from Authorization
//header value
private bool ValidateCredentials(AuthenticationHeaderValue authenticationHeaderVal)
{
try
{
if (authenticationHeaderVal != null
&& !String.IsNullOrEmpty(authenticationHeaderVal.Parameter))
{
string[] decodedCredentials
= Encoding.ASCII.GetString(Convert.FromBase64String(
authenticationHeaderVal.Parameter))
.Split(new[] { ':' });
//now decodedCredentials[0] will contain
//username and decodedCredentials[1] will
//contain password.
if (decodedCredentials[0].Equals("username")
&& decodedCredentials[1].Equals("password"))
{
_userName = "John Doe";
return true;//request authenticated.
}
}
return false;//request not authenticated.
}
catch {
return false;
}
}
protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
//if the credentials are validated,
//set CurrentPrincipal and Current.User
if (ValidateCredentials(request.Headers.Authorization))
{
Thread.CurrentPrincipal = new TestAPIPrincipal(_userName);
HttpContext.Current.User = new TestAPIPrincipal(_userName);
}
//Execute base.SendAsync to execute default
//actions and once it is completed,
//capture the response object and add
//WWW-Authenticate header if the request
//was marked as unauthorized.
//Allow the request to process further down the pipeline
var response = await base.SendAsync(request, cancellationToken);
if (response.StatusCode == HttpStatusCode.Unauthorized
&& !response.Headers.Contains("WwwAuthenticate"))
{
response.Headers.Add("WwwAuthenticate", "Basic");
}
return response;
}
}This class contains a private method ValidateCredentials, which checks for decoded username and password values from the HTTP request header, and also the SendAsync method for intercepting the HTTP request.
If the credentials of the client are valid, then the current IPrincipal object is attached to the current thread, i.e. Thread.CurrentPrincipal. We also set the HttpContext.Current.User to make the security context consistent. This allows us to access the current user's details from anywhere in the application.
Once the request is authenticated, base.SendAsync is called to send the request to the inner handler. If the response contains an HTTP unauthorized header, the code injects a WwwAuthenticate header with the value Basic to inform the client that our service expects basic authentication.
Now, we need to register this handler in the Global.Asax class as we did for our ApiKeyHandler. Make sure that the AuthHandler handler is below the first handler registration to make sure of the right order.
GlobalConfiguration.Configuration.MessageHandlers.Add(new APIKeyHandler()); GlobalConfiguration.Configuration.MessageHandlers.Add(new AuthHandler());
But before we can see basic authentication in action, we will first need to implement authorization.
Authorization is verifying whether the authenticated user can perform a particular action or consume a particular resource. This process in Web API happens later in the pipeline, after
authentication and before the controller actions are executed.
ASP.NET MVC Web API provides an authorization filter called AuthorizeAttribute which verifies the request's IPrincipal, checks its Identity.IsAuthenticated property, and returns a 401 Unauthorized HTTP status if the value is false and the requested action method will not be executed. This filter can be applied in different levels like the controller level or action level, and can be easily applied using the [Authorize] syntax on top of controllers or actions.
[Authorize] public class ClassifiedsController : ApiController
Once this attribute is set, it will prevent all action methods in the controller from being accessed by unauthorized users.
First our basic authentication handler kicks in to set the current user's identity IPrincipal object. Then, before this request reaches the controller, AuthorizeAttribute verifies access to the particular controller/action for the current user.
To see this in action, first let's create an HTTP request without proper credentials.
The access gets denied by the AuthorizeAttribute.
Now, let's create another request with Authorization header key/value this time as follows:
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=
Here, the value dXNlcm5hbWU6cGFzc3dvcmQ= is the Base64-encoded form of username:password.
This request gets access rights to the controller/action as expected.
This is an example of securing the entire controller's public Actions.
We can also restrict some parts of the controller actions by setting the [Authorize] attribute at the action level only instead. Doing so will allow us to have both protected and unprotected actions in the same controller.
//[Authorize]
public class ClassifiedsController : ApiController
{
public List<ClassifiedModel> Get(string id)
{
return ClassifiedService.GetClassifieds(id);
}
[Authorize]
public List<ClassifiedModel> Get()
{
return ClassifiedService.GetClassifieds("");
}Another way to have both protected and unprotected actions within the controller is by making use of the [AllowAnonymous] attribute. When we set the [Authorize] attribute in the controller level and set the [AllowAnonymous] attribute for any action inside the controller, that action will skip the [Authorize] attribute.
It is also possible to filter certain roles and users for access rights. For example, we can have something like [Authorize(Roles = "Admin")] on the controllers and actions.
Finally, we can also create our own custom authorization attribute depending upon our needs. One of the ways to achieve this is by extending AuthorizeAttribute.
Say we want to restrict our Web API service to only certain parts of the world by restricting access to users that are not within a certain range of IP address. We can create a custom authorize attribute for this purpose by deriving from the AuthorizeAttribute class and overriding the IsAuthorized method.
public class RestrictIPsAttribute: System.Web.Http.AuthorizeAttribute
{
protected override bool IsAuthorized(HttpActionContext context)
{
var ip = HttpContext.Current.Request.UserHostAddress;
//check for ip here
if (ip.Contains(""))
{
return true;
}
return false;
}
}Once we have our custom Authorize attribute, we can decorate our controllers/actions with it.
[RestrictIPsAttribute]
public List<ClassifiedModel> Get()
{
return ClassifiedService.GetClassifieds("");
}In this article, we looked at how we can secure our ASP.NET Web API service before exposing the service to the world outside. We looked at how we can authenticate HTTP requests for valid API keys and for valid user credentials. With this much knowledge in hand, I believe we ready to develop any custom security for our APIs.
For those of you who are either just getting started with Laravel or looking to expand your knowledge, site, or application with extensions, we have a variety of things you can study in Envato Market.
I hope you enjoyed reading as much as learning from this article, and remember to leave any questions or comments in the feed below!
Create Modern Vue Apps Using Create-Vue and Vite
/
5Pros and Cons of Using WordPress
/
-4How to Fix the “There Has Been a Critical Error in Your Website” Error in WordPress
/
1How To Fix The “There Has Been A Critical Error in Your Website” Error in WordPress
How to Create a Privacy Policy Page in WordPress
/
8WordPress Website Maintenance Guide For Beginners
/
6How Long Does It Take to Learn JavaScript?
/
-1How Long Does it Take to Learn JavaScript
/
1The Best Way to Deep Copy an Object in JavaScript
/
-2
4
-5Adding and Removing Elements From Arrays in JavaScript
/
-2Create a JavaScript AJAX Post Request: With and Without jQuery
/
75 Real-Life Uses for the JavaScript reduce() Method
/
-9How to Enable or Disable a Button With [removed] jQuery vs. Vanilla
/
4How to Enable or Disable a Button With [removed] jQuery vs Vanilla
/
-4Confirm Yes or No With JavaScript
/
-1How to Change the URL in [removed] Redirecting
/
-315+ Best WordPress Twitter Widgets
/
-227 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/
1021 Best Tab and Accordion Widget Plugins for WordPress (Free & Premium)
/
-1130 HTML Best Practices for Beginners
/
-831 Best WordPress Calendar Plugins and Widgets (With 5 Free Plugins)
/
525 Ridiculously Impressive HTML5 Canvas Experiments
/
-7
1How to Implement Email Verification for New Members
/
3How to Create a Simple Web-Based Chat Application
/
530 Popular WordPress User Interface Elements
/
-5Top 18 Best Practices for Writing Super Readable Code
/
3Best Affiliate WooCommerce Plugins Compared
/
-1018 Best WordPress Star Rating Plugins
/
1410+ Best WordPress Twitter Widgets
/
420+ Best WordPress Booking and Reservation Plugins
/
5Working With Tables in React: Part Two
/
-4Best CSS Animations and Effects on CodeCanyon
/
-1630 CSS Best Practices for Beginners
/
4How to Create a Custom WordPress Plugin From Scratch
/
510 Best Responsive HTML5 Sliders for Images and Text… and 3 Free Options
/
-416 Best Tab and Accordion Widget Plugins for WordPress
/
-418 Best WordPress Membership Plugins and 5 Free Plugins
/
325 Best WooCommerce Plugins for Products, Pricing, Payments and More
/
310 Best WordPress Twitter Widgets
1 /
1512 Best Contact Form PHP Scripts for 2020
/
-320 Popular WordPress User Interface Elements
/
-210 Best WordPress Star Rating Plugins
/
-312 Best CSS Animations on CodeCanyon
/
112 Best WordPress Booking and Reservation Plugins
/
220 Best WordPress Calendar Plugins and Widgets
/
-212 Elegant CSS Pricing Tables for Your Latest Web Project
/
724 Best WordPress Form Plugins for 2020
/
-314 Best PHP Event Calendar and Booking Scripts
/
-1Create a Blog for Each Category or Department in Your WooCommerce Store
/
18 Best WordPress Booking and Reservation Plugins
/
-18Best Exit Popups for WordPress Compared
/
20Best Exit Popups for WordPress Compared
/
-611 Best Tab & Accordion WordPress Widgets & Plugins
/
-1012 Best Tab & Accordion WordPress Widgets & Plugins
1 /
1New Course: Practical React Fundamentals
/
3Short Course: Better Angular App Architecture With Modules
/
2Preview Our New Course on Angular Material
/
5Object-Oriented PHP With Classes and Objects
/
3Best Practices for ARIA Implementation
/
-2Accessible Apps: Barriers to Access and Getting Started With Accessibility
/
-3Dramatically Speed Up Your React Front-End App Using Lazy Loading
/
1915 Best Modern JavaScript Admin Templates for React, Angular, and Vue.js
/
-1515 Best Modern JavaScript Admin Templates for React, Angular and Vue.js
/
319 Best JavaScript Admin Templates for React, Angular, and Vue.js
/
3New Course: Build an App With JavaScript and the MEAN Stack
/
10Hands-on With ARIA: Accessibility Recipes for Web Apps
/
810 Best WordPress Facebook Widgets
13 /
-5Hands-on With ARIA: Accessibility for eCommerce
/
6New eBooks Available for Subscribers
/
-5Hands-on With ARIA: Homepage Elements and Standard Navigation
/
10
-9Site Accessibility: Getting Started With ARIA
/
4How Secure Are Your JavaScript Open-Source Dependencies?
/
-1New Course: Secure Your WordPress Site With SSL
/
-3Testing Components in React Using Jest and Enzyme
/
-8Testing Components in React Using Jest: The Basics
/
-415 Best PHP Event Calendar and Booking Scripts
/
-1Create Interactive Gradient Animations Using Granim.js
/
11How to Build Complex, Large-Scale Vue.js Apps With Vuex
1 /
1Examples of Dependency Injection in PHP With Symfony Components
/
-4Set Up Routing in PHP Applications Using the Symfony Routing Component
1 /
11A Beginner’s Guide to Regular Expressions in JavaScript
/
12Introduction to Popmotion: Custom Animation Scrubber
/
-4Introduction to Popmotion: Pointers and Physics
/
-10New Course: Connect to a Database With Laravel’s Eloquent ORM
/
-5How to Create a Custom Settings Panel in WooCommerce
/
-12Building the DOM faster: speculative parsing, async, defer and preload
1 /
120 Useful PHP Scripts Available on CodeCanyon
3 /
49How to Find and Fix Poor Page Load Times With Raygun
/
2Introduction to the Stimulus Framework
/
-14Single-Page React Applications With the React-Router and React-Transition-Group Modules
/
1
612 Best Contact Form PHP Scripts
1 /
-4Getting Started With the Mojs Animation Library: The ShapeSwirl and Stagger Modules
/
2Getting Started With the Mojs Animation Library: The Shape Module
/
-4Getting Started With the Mojs Animation Library: The HTML Module
/
4Project Management Considerations for Your WordPress Project
/
-98 Things That Make Jest the Best React Testing Framework
/
3Creating an Image Editor Using CamanJS: Layers, Blend Modes, and Events
/
-3New Short Course: Code a Front-End App With GraphQL and React
Creating an Image Editor Using CamanJS: Applying Basic Filters
/
-12Creating an Image Editor Using CamanJS: Creating Custom Filters and Blend Modes
/
1Challenge: Create a To-Do List in React
1 /
1Deploy PHP Web Applications Using Laravel Forge
/
-1Getting Started With the Mojs Animation Library: The Burst Module
/
5
-910 Things Men Can Do to Support Women in Tech
/
1A Gentle Introduction to Higher-Order Components in React: Best Practices
/
-4Challenge: Build a React Component
/
-4A Gentle Introduction to HOC in React: Learn by Example
/
5A Gentle Introduction to Higher-Order Components in React
/
-7Creating Pretty Popup Messages Using SweetAlert2
/
5Creating Stylish and Responsive Progress Bars Using ProgressBar.js
/
1718 Best Contact Form PHP Scripts for 2022
/
-3Creating a Blogging App Using Angular & MongoDB: Delete Post
/
-17Set Up an OAuth2 Server Using Passport in Laravel
/
1Creating a Blogging App Using Angular & MongoDB: Edit Post
/
-2Creating a Blogging App Using Angular & MongoDB: Add Post
/
-1Creating a Blogging App Using Angular & MongoDB: Show Post
/
8Creating a Blogging App Using Angular & MongoDB: Home
/
10
2Creating a Blogging App Using Angular & MongoDB: Login
/
13Creating Your First Angular App: Implement Routing
/
13Persisted WordPress Admin Notices: Part 4
/
-4Creating Your First Angular App: Components, Part 2
/
3Persisted WordPress Admin Notices: Part 3
/
3How Laravel Broadcasting Works
/
1
9Persisted WordPress Admin Notices: Part 2
/
-3Create Your First Angular App: Storing and Accessing Data
/
2Persisted WordPress Admin Notices: Part 1
/
-3Error and Performance Monitoring for Web & Mobile Apps Using Raygun
/
6Using Luxon for Date and Time in JavaScript
7 /
-5How to Create an Audio Oscillator With the Web Audio API
/
-6How to Cache Using Redis in Django Applications
/
220 Essential WordPress Utilities to Manage Your Site
/
-5Introduction to API Calls With React and Axios
/
18Beginner’s Guide to Angular 4: HTTP
/
11Rapid Web Deployment for Laravel With GitHub, Linode, and RunCloud.io
/
8Beginners Guide to Angular 4: Routing
/
-9Beginner’s Guide to Angular 4: Components
/
1Creating a Drop-Down Menu for Mobile Pages
/
3Introduction to Forms in Angular 4: Writing Custom Form Validators
/
510 Best WordPress Booking & Reservation Plugins
/
2Getting Started With Redux: Connecting Redux With React
/
15Getting Started With Redux: Learn by Example
/
16Getting Started With Redux: Why Redux?
/
9Understanding Recursion With JavaScript
/
-2How to Auto Update WordPress Salts
/
-8How to Download Files in Python
/
-3
-22Eloquent Mutators and Accessors in Laravel
1 /
17
-11
1210 Best HTML5 Sliders for Images and Text
/
5Site Authentication in Node.js: User Signup
/
-4Creating a Task Manager App Using Ionic: Part 2
/
2Creating a Task Manager App Using Ionic: Part 1
/
1
3Introduction to Forms in Angular 4: Template-Driven Forms
/
-124 Essential WordPress Utilities to Manage Your Site
/
-125 Essential WordPress Utilities to Manage Your Site
/
-12Get Rid of Bugs Quickly Using BugReplay
1 /
-14Manipulating HTML5 Canvas Using Konva: Part 1, Getting Started
/
710 Must-See Easy Digital Downloads Extensions for Your WordPress Site
22 Best WordPress Booking and Reservation Plugins
/
-5Understanding ExpressJS Routing
/
-515 Best WordPress Star Rating Plugins
/
12Inheritance and Extending Objects With JavaScript
/
-8Introduction to the CSS Grid Layout With Examples
1 /
2
8Performant Animations Using KUTE.js: Part 5, Easing Functions and Attributes
/
-8Performant Animations Using KUTE.js: Part 4, Animating Text
/
-12Performant Animations Using KUTE.js: Part 3, Animating SVG
/
-9New Course: Code a Quiz App With Vue.js
/
-1Performant Animations Using KUTE.js: Part 2, Animating CSS Properties
/
3
9Performant Animations Using KUTE.js: Part 1, Getting Started
/
410 Best Responsive HTML5 Sliders for Images and Text (Plus 3 Free Options)
/
-3Single-Page Applications With ngRoute and ngAnimate in AngularJS
/
-12Deferring Tasks in Laravel Using Queues
/
-5
4Site Authentication in Node.js: User Signup and Login
/
11Working With Tables in React, Part Two
/
-16Working With Tables in React, Part One
/
6How to Set Up a Scalable, E-Commerce-Ready WordPress Site Using ClusterCS
/
-2New Course on WordPress Conditional Tags
/
4
-11Building With Vue.js 2 and Firebase
6 /
10
-6
1Best Unique Bootstrap JavaScript Plugins
/
-10
-5Essential JavaScript Libraries and Frameworks You Should Know About
/
7
3Vue.js Crash Course: Create a Simple Blog Using Vue.js
/
-13Build a React App With a Laravel RESTful Back End: Part 1, Laravel 5.5 API
/
4API Authentication With Node.js
/
-4Beginner’s Guide to Angular: HTTP
/
7Beginner’s Guide to Angular: Routing
/
-4Beginners Guide to Angular: Routing
/
-6Beginner’s Guide to Angular: Services
/
5Beginner’s Guide to Angular: Components
/
-1How to Create a Custom Authentication Guard in Laravel
/
7Learn Computer Science With [removed] Part 3, Loops
/
-3Build Web Applications Using Node.js
/
2Learn Computer Science With [removed] Part 4, Functions
/
3Learn Computer Science With [removed] Part 2, Conditionals
/
12Learn Computer Science With [removed] Part 1, The Basics
/
-5Create Interactive Charts Using Plotly.js, Part 5: Pie and Gauge Charts
/
-8Create Interactive Charts Using Plotly.js, Part 4: Bubble and Dot Charts
/
18Create Interactive Charts Using Plotly.js, Part 3: Bar Charts
/
-14Awesome JavaScript Libraries and Frameworks You Should Know About
/
-4Create Interactive Charts Using Plotly.js, Part 2: Line Charts
/
-8Bulk Import a CSV File Into MongoDB Using Mongoose With Node.js
/
-4Build a To-Do API With Node, Express, and MongoDB
/
-6Getting Started With End-to-End Testing in Angular Using Protractor
/
10TypeScript for Beginners, Part 4: Classes
/
-10Object-Oriented Programming With JavaScript
/
610 Best Affiliate WooCommerce Plugins Compared
/
9Stateful vs. Stateless Functional Components in React
/
11Make Your JavaScript Code Robust With Flow
/
-6Build a To-Do API With Node and Restify
/
7Testing Components in Angular Using Jasmine: Part 2, Services
/
1Testing Components in Angular Using Jasmine: Part 1
/
-2Creating a Blogging App Using React, Part 6: Tags
/
-11React Crash Course for Beginners, Part 3
/
3React Crash Course for Beginners, Part 2
/
12React Crash Course for Beginners, Part 1
/
2Set Up a React Environment, Part 4
1 /
8Set Up a React Environment, Part 3
/
-11New Course: Get Started With Phoenix
/
-11Set Up a React Environment, Part 2
/
2Command Line Basics and Useful Tricks With the Terminal
/
3How to Create a Real-Time Feed Using Phoenix and React
/
-8Build a React App With a Laravel Back End: Part 2, React
/
2Build a React App With a Laravel RESTful Back End: Part 1, Laravel 9 API
/
-7Creating a Blogging App Using React, Part 5: Profile Page
/
-5Pagination in CodeIgniter: The Complete Guide
/
22JavaScript-Based Animations Using Anime.js, Part 4: Callbacks, Easings, and SVG
/
-1JavaScript-Based Animations Using Anime.js, Part 3: Values, Timeline, and Playback
Learn to Code With [removed] Part 1, The Basics
/
510 Elegant CSS Pricing Tables for Your Latest Web Project
/
-6Getting Started With the Flux Architecture in React
/
-2Getting Started With Matter.js: The Composites and Composite Modules
/
4Getting Started With Matter.js: The Engine and World Modules
/
1410 More Popular HTML5 Projects for You to Use and Study
/
-24Understand the Basics of Laravel Middleware
/
-6Iterating Fast With Django & Heroku
/
8Creating a Blogging App Using React, Part 4: Update & Delete Posts
/
3Creating a jQuery Plugin for Long Shadow Design
/
-9How to Register & Use Laravel Service Providers
2 /
-13Unit Testing in React: Shallow vs. Static Testing
/
5Creating a Blogging App Using React, Part 3: Add & Display Post
/
15Creating a Blogging App Using React, Part 2: User Sign-Up
20 /
-5Creating a Blogging App Using React, Part 1: User Sign-In
/
99 More Popular HTML5 Projects for You to Use and Study
/
18Creating a Grocery List Manager Using Angular, Part 2: Managing Items
/
99 Elegant CSS Pricing Tables for Your Latest Web Project
/
1Dynamic Page Templates in WordPress, Part 3
/
-2Angular vs. React: 7 Key Features Compared
/
6Creating a Grocery List Manager Using Angular, Part 1: Add & Display Items
/
2New eBooks Available for Subscribers in June 2017
/
7Create Interactive Charts Using Plotly.js, Part 1: Getting Started
/
11The 5 Best IDEs for WordPress Development (And Why)
/
233 Popular WordPress User Interface Elements
/
2New Course: How to Hack Your Own App
/
-10How to Install Yii on Windows or a Mac
/
5What Is a JavaScript Operator?
/
-5How to Register and Use Laravel Service Providers
/
8
waly Good blog post. I absolutely love this…