PHP7 Features

With that out of the way, let’s check out PHP 7.

1. The Name’s PHP 7 (Not 6)

The current stable release uses the version number PHP 5.6. After some dispute the development team decided they would omit the PHP 6 name for the next major release. PHP 6 already existed in the past as an experimental project but never reached the production phase.

To prevent users from mixing up the former attempt with the latest development, the new major release will run under the name of PHP 7.

2. The Brand Spanking New Zend Engine

The Zend engine has been powering PHP since 1999 when it was introduced with the then new PHP 4 release. Zend – not to confused with the Zend Framework – is an open-source execution engine written in C that interprets the PHP language. The current PHP 5.X series use Zend Engine II that enhanced the funtionality of the initial engine and adds an extensible object model and a significant performance enhancement to the language.

3. Twice The Speed

The most easily recognizable advantage of the new PHPNG engine is the significant performance improvement. The development team of PHPNG refactored the Zend Engine, and remarkably o

4. Facilitates Error Handling

To say the least, handling fatal and catchable fatal errors have never been an easy task for PHP coders. The new Engine Exceptions will allow you to replace these kind of errors with exceptions. If the exception is not caught, PHP will continue to return the same fatal errors as it does in the current 5.X series.

The new \EngineException objects don’t extend the \Exception Base Class. This ensures backward compatibility and results in two different kinds of exceptions in error handling: traditional and engine exceptions.

To enable programmers to catch both, PHP 7 introduces a new shared Parent Class under the name of \BaseException.

IMAGE: Wiki.PHP.net

5. 64-Bit Windows Systems Support

PHP is a prominent member of the LAMP stack which means its native environment is Linux – but it’s also possible to run it on a Windows system. The 5.X series don’t yet provide 64-bit integer or large file support, so until now x64 builds have been considered experimental.

PHP 7 will change this as it introduces consistent 64-bit support which means both native 64-bit integers and large files will be supported, allowing you to confidently run the language on your 64-bit Windows system in the future.ptimized memory usage.

The results? You can see the performance benchmarks provided by the Zend Performance Team below. By using PHP 7 not only your code will be executed faster but you will also need fewer servers to serve the same amount of users.

6. New Spaceship and Null Coalescing Operators

The Spaceship operator runs under the official name of Combined Comparison Operator. The notation of the new operator looks like this: <=> (kind of like a simplified spaceship, if you imagine it right).

The spacehip operator returns 0 if both operands are equal, 1 if the left is greater, and -1 if the right is greater. It’s also called a three-way comparison operator, and it already exists in other popular programming languages like Perl and Ruby.

IMAGE: Wiki.PHP.net

The Null Coalescing operator is denoted with two question marks ( ?? ). You can use it when you want to check if something exists and return a default value, in case it doesn’t. The coalesce operator returns the result of its first operand if it exists and is not null, and the second operand in any other cases.

Here’s how the new operator reduces the time spent with basic declarations:

IMAGE: Wiki.PHP.net

7. Enables Accurate Type Declarations

Have you ever wanted to prevent unintended return values by declaring the return type of a function? Well, the new PHP 7 enables developers to enhance the quality of their code with the help of return type declarations.

The image below depicts a very simple use case where the foo() function is supposed to return an array. Check out more complicated examples here.

IMAGE: Wiki.PHP.net

To enhance the feature even more, PHP 7 introduces 4 new type declarations for scalar types: int, float, string and bool. The new scalar types allow developers to denote that they are expecting integers, floats, strings, or booleans to be returned. The new scalar types introduced by PHP 7 will also be supported by argument Type Hints that enables developers to force the type of parameters since the PHP 5.X series.

8. Adds Anonymous Classes

PHP 7 enables you to use anonymous classes, already a well-established practice in other object-oriented languages like C# and Java. An anonymous class is a class without a name. The object it instantiates has the same functionality as an object of a named class.

The syntax is the same as what we are used to in traditional PHP classes, only the name is missing. If anonymous classes are used well, they can speed up coding as well execution time. Anonymous classes are excellent when a class is used only once during execution and in cases when a class doesn’t need to be documented.

IMAGE: Wiki.PHP.net

9. Facilitates Imports From the Same Namespace

The new Group Use Declarations feature will be godsent to those of you who want to import many classes from the same namespace. The new syntax cuts verbosity, makes your code tidier and easier on the eyes, and saves you a lot of typing time.

It will also be easier to read through and debug codes, as group use declarations help you identify the imports that belong to the same module.

IMAGE: Wiki.PHP.net

10. Cleans Up The Room

The goal of PHP 7 was to free up the space to enable improvement, so it was necessary to get rid of many deprecated functionalities and old and unsupported Server APIs and extensions. If you want to check which are these in detail, click here and here.

All the removed items have been deprecated for a while in PHP 5 so most likely you haven’t used them for a long time. However please note if you have a legacy app running on older PHP versions the new PHP 7 can potentially break the code.

why to use framework

down voteaccepted

Framework abstracts you from low level details, makes you more productive, and protects you from low level error ( such as preventing SQL injection attacks). A good PHP framework forces you to separate your concern and implements the proven architecture, which in the end improves your design, and makes your code much easier to read and maintain and unit test. A framework streamlines application development by automating many of the patterns employed for a given purpose. A framework also adds structure to the code, prompting the developer to write better, more readable, and more maintainable code. Ultimately, a framework makes programming easier, since it packages complex operations into simple statements. For a simple web application or a website with basic features it’s wiser to use some good open source system. However for more complex and bespoke functionality requirement it’s more recommended to work with framework. Huge amount of development time can be saved with the use of Frameworks due to availability of large variety of tools like input sanitization and abstraction layers in particular. It's very common scenario in website development companies where clients are really pressurizing and so often demand quick turnaround. Frameworks can be real life savers under high pressure as they help enormously in quickly delivering repetitive and commons tasks. There are pretty good reasons to use the Frameworks: Code and file organization is extremely easy Countless numbers of tools and libraries that can help you with: Form validation Database abstraction Input/Output filtering Session and Cookie handling Email, Calender and pagination and much more MVC (Model View Controller) Architecture Less code which ultimately speeds up your development Security - PHP has many input and output filtering functions which can add extra security layer to protect your website against certain attacks Suitable for teamwork PHP frameworks have great active community support. You will find the accurate solution of any query quickly

why to use javascript frameworks ?

Don't Reinvent The Wheel

Why write code that's already been written (better)? A good programmer is a lazy programmer, so be lazy. The tools are there -- use them

Do More With Less Code

Most JavaScript frameworks provide function "chaining." Chaining allows you to do more with less code. Less code means less maintenance time, less download time, and less coding time. Check out MooTools chaining.

Save Time -- You Don't Code Your Own OS, Do You?

I love JavaScript as much as the next guy, but some programmers REALLY love developing JavaScript. Let the experts do the tough part, you take their work and make what you'd like of it.

Chances Are, You Aren't The Expert

As big as any programmer's ego is, there are people out there that are smarter, more inventive than you. Most Web Developers need to be a jack of all trades and it's difficult to keep up with every language when you're needed in every facet of a website's construction and launch. The minds behind the frameworks have their eyes on JavaScript daily -- trust in them.

Speed Thrills

The creators of these JavaScript frameworks have their own private pissing contest when it comes to JavaScript speed put a lot of effort into making sure their frameworks are fast. The first job of JavaScript for mass web visitor usage is to be fast -- users expect accuracy, speed is the most important part. Who's fastest today? Check out SlickSpeed.

Avoid Cryptic JavaScript Base Code

Why use JavaScript's default functions when you can use a framework's English-named functions? For example:

//standard JavaScript
document.getElementbyId('mydiv').style.color = '#f00'; // camel-case the style!

//mootools JavaScript
$('mydiv').setStyle('color','#foo');

These are the reasons I use JavaScript frameworks. Need I say more?

7. Unified browser API, most of the time You dont have to think about browser compatibility because guys from Your framework took care (btw. I love jQuery).

Random Question Answers

What is CORS? How does it work?

Cross-origin resource sharing (CORS) is a mechanism that allows many resources (e.g., fonts, JavaScript, etc.) on a web page to be requested from another domain outside the domain from which the resource originated. It’s a mechanism supported in HTML5 that manages XMLHttpRequest access to a domain different.

CORS adds new HTTP headers that provide access to permitted origin domains. For HTTP methods other than GET (or POST with certain MIME types), the specification mandates that browsers first use an HTTP OPTIONS request header to solicit a list of supported (and available) methods from the server. The actual request can then be submitted. Servers can also notify clients whether “credentials” (including Cookies and HTTP Authentication data) should be sent with requests.

Explain the purpose of each of the HTTP request types when used with a RESTful web service.

The purpose of each of the HTTP request types when used with a RESTful web service is as follows:

1. GET: Retrieves data from the server (should only retrieve data and should have no other effect).
2. POST: Sends data to the server for a new entity. It is often used when uploading a file or submitting a completed web form.
3. PUT: Similar to POST, but used to replace an existing entity.
4. PATCH: Similar to PUT, but used to update only certain fields within an existing entity.
5. DELETE: Removes data from the server.
6. TRACE: Provides a means to test what a machine along the network path receives when a request is made. As such, it simply returns what was sent.
7. OPTIONS: Allows a client to request information about the request methods supported by a service. The relevant response header is Allow and it simply lists the supported methods. (It can also be used to request information about the request methods supported for the server where the service resides by using a * wildcard in the URI.)
8. HEAD: Same as the GET method for a resource, but returns only the response headers (i.e., with no entity-body).
9. CONNECT: Primarily used to establish a network connection to a resource (usually via some proxy that can be requested to forward an HTTP request as TCP and maintain the connection). Once established, the response sends a 200 status code and a “Connection Established” message.

Explain the basic structure of a MIME multipart message when used to transfer different content type parts. Provide a simple example

A simple example of a MIME multipart message is as follows:

MIME-Version: 1.0
Content-Type: multipart/mixed; boundary=frontier

This is a message with multiple parts in MIME format.
--frontier
Content-Type: text/plain

This is the body of the message.
--frontier
Content-Type: application/octet-stream
Content-Transfer-Encoding: base64

PGh0bWw+CiAgPGhlYWQ+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPHA+VGhpcyBpcyB0aGUg
Ym9keSBvZiB0aGUgbWVzc2FnZS48L3A+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==
--frontier--

Each MIME message starts with a message header. This header contains information about the message content and boundary. In this case Content-Type: multipart/mixed; boundary=frontier means that message contains multiple parts where each part is of different content type and they are separated by --frontier as their boundary.

Each part consists of its own content header (zero or more Content- header fields) and a body. Multipart content can be nested. The content-transfer-encoding of a multipart type must always be 7bit, 8bit, or binary to avoid the complications that would be posed by multiple levels of decoding. The multipart block as a whole does not have a charset; non-ASCII characters in the part headers are handled by the Encoded-Word system, and the part bodies can have charsets specified if appropriate for their content-type.

What is Long polling, how does it work, and why would you use it? Considering server and client resources, what is the main drawback of using long polling? Which HTML5 feature is the best alternative to long polling

The HTTP protocol is based on a request/response pattern, which means that the server cannot push any data to the client (i.e., the server can only provide data to the client in response to a client request). Long polling is a web application development pattern used to emulate pushing data from server to client. When the long polling pattern is used, the client submits a request to the server and the connection then remains active until the server is ready to send data to the client. The connection is closed only after data is sent back to the client or connection timeout occurs. The client then creates a new request when the connection is closed, thus restarting the loop.

There are two important drawbacks that need to be considered when using long polling:

1. Long polling requests are not different from any other HTTP request and web servers handle them the same way. This means that every long poll connection will reserve server resources, potentially maxing out the number of connections the server can handle. This can lead to HTTP connection timeouts.
2. Each web browser will limit the maximum number of connections web application can make. This means that your application load time and performance may be degraded.

In HTML5, a useful alternative to long polling is using a WebSocket. A WebSocket is a protocol providing full-duplex communications channels over a single TCP connection. The WebSocket protocol makes possible more interaction between a browser and a web site, facilitating live content and eliminates the need for the long polling paradigm.

Another potential answer could be Server-sent DOM Events. Which is method of continuously sending data from a server to the browser, rather than repeatedly requesting it. However, this HTML5 feature is not supported by Microsoft Internet Explorer, thus making it less attractive solution.

What is an ETag and how does it work?

An ETag is an opaque identifier assigned by a web server to a specific version of a resource found at an URL. If the resource content at that URL ever changes, a new and different ETag is assigned.

In typical usage, when an URL is retrieved the web server will return the resource along with its corresponding ETag value, which is placed in an HTTP “ETag” field:

ETag: "unique_id_of_resource_version"

The client may then decide to cache the resource, along with its ETag. Later, if the client wants to retrieve the same URL again, it will send its previously saved copy of the ETag along with the request in a "If-None-Match" field.

If-None-Match: "unique_id_of_resource_version"

On this subsequent request, the server may now compare the client’s ETag with the ETag for the current version of the resource. If the ETag values match, meaning that the resource has not changed, then the server may send back a very short response with a HTTP 304 Not Modified status. The 304 status tells the client that its cached version is still good and that it should use that.

However, if the ETag values do not match, meaning the resource has likely changed, then a full response including the resource’s content is returned, just as if ETag were not being used. In this case the client may decide to replace its previously cached version with the newly returned resource and the new ETag.

Explain the difference between stateless and stateful protocols. Which type of protocol is HTTP? Explain your answer.

A stateless communications protocol treats each request as an independent transaction. It therefore does not require the server to retain any session, identity, or status information spanning multiple requests from the same source. Similarly, the requestor can not rely on any such information being retained by the responder.

In contrast, a stateful communications protocol is one in which the responder maintains “state” information (session data, identity, status, etc.) across multiple requests from the same source.

HTTP is a stateless protocol. HTTP does not require server to retain information or status about each user for the duration of multiple requests.

Some web servers implement states using different methods (using cookies, custom headers, hidden form fields etc.). However, in the very core of every web application everything relies on HTTP which is still a stateless protocol that is based on simple request/response paradigm.

Describe the key advantages of HTTP/2 as compared with HTTP 1.1.

HTTP/2 provides decreased latency to improve page load speed by supporting:

• Data compression of HTTP headers
• Server push technologies
• Loading of page elements in parallel over a single TCP connection
• Prioritization of requests

An important operational benefit of HTTP/2 is that it avoids the head-of-line blocking problem in HTTP 1.