convert pdf byte array to image byte array c# : Convert pdf to form fillable software SDK cloud windows .net web page class ultimate-guide-drupal-82-part1128

21   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Configuration and Content Entities
Nearly anything you can create more than one of in Drupal 8 has been converted to 
an entity, bringing greater consistency to Drupal development. There are two kinds of 
these entities: Config entities and Content entities. What’s the difference?
Content entities sport some nifty new features compared to Drupal 7, like revisions 
aren’t just for nodes anymore (!) and the ability to add comments to any content 
entity (users, taxonomy terms… you can even have comments on comments!). The 
“Site Builder Improvements” chapter of this ebook has more information about 
other entity-related features.
Wither hook_schema()? 
What does this mean for you as a developer? It means that between the Entity 
API and the Configuration/State API, there is almost never a reason to create and 
manage your own database tables by hand in Drupal 8. By using these standard 
APIs, you’ll benefit from writing less brittle code and benefit from portability to other 
databases such as MongoDB.
Web Services
A major focus for Drupal 8 is a native REST API built into Drupal 8 and supported by 
the RESTful Web Services suite of modules. These enable Drupal 8 to produce 
and consume web services for the creation of Drupal-powered mobile applications, 
facilitate cross-site communication, and allow better integration with third-party 
resources, for example in micro-services-style applications. 
The Drupal 8 REST API allows for fine-grained configuration of which resources 
should be available (nodes, taxonomy, users, and so on), what HTTP methods 
are allowed against those resources (for example, GET, POST, PATCH, DELETE), 
and which formats and authentication are used to access those resources. The 
contributed REST UI module provides an interface for this configuration. You 
can define which role(s) on your site may access resources via each allowed 
HTTP method. For example, you can allow anonymous users to GET but only 
administrators to POST. Once the various RESTful Web Services modules are 
configured properly, you can expose machine-readable data representing your  
site content, like this:  
...
[title] => Array
(
[0] => Array
(
[value] => Hello, world!
[lang] => en
)
)
...
[body] => Array
(
[0] => Array
(
[value] => <p>This is my <strong>awesome
</strong> article.</p>
[format] => basic_html
[summary] =>
)
)
What good is that? Plenty! Here’s one example of retrieving information from  
Drupal 8 in JSON and displaying it in a standalone jQuery Mobile app .
Drupal 8 ships with the Guzzle PHP HTTP library, which gives us easy syntax  
to retrieve and post data to Drupal or to talk to third-party Web Services, such  
as Twitter or Github.
Content Entities
Config Entities
Ž
Customized fields
Ž
Stored in database tables (by default)
Ž
Mostly created on front-end
Ž
Deployed to different environments
Ž
Stored in configuration system
Ž
Mostly created on back-end
Examples
Examples
Ž
Nodes
Ž
Custom Blocks
Ž
Users
Ž
Comments
Ž
Taxonomy Terms
Ž
Menu Links
Ž
Aggregator Feeds/Items
Ž
Content Types
Ž
Custom Block Types
Ž
User Roles
Ž
Views
Ž
Taxonomy Vocabularies
Ž
Menus
Ž
Image Styles
Convert pdf to form fillable - C# PDF Form Data fill-in Library: auto fill-in PDF form data in C#.net, ASP.NET, MVC, WinForms, WPF
Online C# Tutorial to Automatically Fill in Field Data to PDF
add signature field to pdf; allow users to attach to pdf form
Convert pdf to form fillable - VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
VB.NET PDF Form Data fill-in library: auto fill-in PDF form data in vb.net, ASP.NET, MVC, WinForms, WPF
convert pdf to form fillable; create a fillable pdf form from a word document
22   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Another Web Services feature in Drupal 8 offered by the RESTful Web Services 
module is the ability to add a “REST export” display to any view.
This means you can easily create JSON or XML feeds of custom dynamic content 
from your Drupal site, just by clicking them together!
Improved Caching
And on a final happy note, caching in Drupal 8 has been improved across the board.
Ž
Entity cache module is now in core.
Ž
Cache tags allow for much more granular cache clearing when content  
or settings are updated on the site.
Ž
All caching features such as CSS/JS aggregation are turned on out of the  
box, making Drupal 8 fast by default.
BigPipe
Activating the experimental BigPipe Module in Drupal 8.1 core improves the user 
experience for your site visitors by reducing the perceived page loading time. Drupal 
7 can’t really cache its output because it lacks metadata for caching. In Drupal 7 
(and just about every other CMS or framework), personalization has always made 
things run slower. Using BigPipe in Drupal 8, it is no longer so. Drupal 8 includes 
cacheability metadata and knows which parts of every page are static and which 
dynamic. BigPipe then sends the unchanging parts of a page to the browser 
immediately while rendering and delivering the dynamic parts later, as soon as 
they are ready. Essentially, your site visitors see what they came to see almost 
immediately—the main content and images, for example—while the uncacheable, 
personalized page elements (such as a shopping cart block) are delivered once 
rendered.
The changes to Drupal 8’s rendering pipeline that make BigPipe possible are  
also what made ESI and Drupal 8’s Dynamic Page Cache possible.
Learn more about BigPipe in Drupal 8 in this blog post and in this webinar – 
BigPipe: The Architecture Behind the Fastest Version of Drupal Yet  
– with Wim Leers.
VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to
URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Dim doc As PPTXDocument = New PPTXDocument(inputFilePath) ' Convert it to a PDF.
add fillable fields to pdf online; convert pdf fillable form to word
VB.NET Create PDF from Word Library to convert docx, doc to PDF in
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Convert Word to PDF file with embedded fonts or without original fonts
create fill in pdf forms; create fillable form pdf online
23   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Better, Right Down to the Core
Drupal 8 made some major API changes that embrace the way the rest of the 
world works.
“Proudly Found Elsewhere”
As a counterpoint to our earlier sense of self-sufficiency and rejection of third-
party code, expressed as “Not Invented Here”, “Proudly Invented Elsewhere” 
represents a mind-shift among Drupal core developers. One of the great strengths 
of open source software is in not having to reinvent the wheel and being able to 
build better solutions “on the shoulders of giants.” It means opening our open 
source project and finding the best tool for the job, versus creating something 
custom and specific to Drupal. So we benefit from having a broader community of 
contributors and users, and when we make improvements to these open source 
tools, everyone who uses them benefits, too.
You’ll see this philosophy change many aspects of Drupal 8. Among the external 
libraries we’ve pulled in are PHPUnit for unit testing, Guzzle for performing 
HTTP (web service) requests, a variety of Symfony components (Create your 
own framework on top of the Symfony2 Components is an excellent tutorial for 
learning more about those), and Composer for pulling in external dependencies 
and class autoloading, and more. 
But this philosophy change also extends to the code base itself. We made big 
architecture changes in Drupal 8 to embrace the way the rest of the world is 
writing code: decoupled, object-oriented (OO), and embracing modern language 
features of PHP, such as namespaces and traits.
Getting OOP-y with It
Let’s look at a few code samples to illustrate Drupal 8’s “Proudly Found Elsewhere” 
architecture in action.
Drupal 7: example.info
name = Example
description = An example module.
core = 7.x
files[] = example.test
dependencies[] = user
All modules in Drupal need a .info file to register themselves with the system. The 
example above is typical of a Drupal 7 module. The file format is “INI-like” for ease 
of authoring, but also includes some “Drupalisms” such as the array[] syntax so 
standard PHP functions for reading/writing INI files can’t be used. The files[] key, 
which triggers Drupal 7’s custom class autoloader to add code to the registry table, 
is particularly Drupalish, and module developers writing OO code must add a files[] 
line for each file that defines a class, which can get a little bit silly.
Drupal 8: example.info.yml
name: Example
description: An example module.
core: 8.x
dependencies:
- user
# Note: New property required as of Drupal 8!
type: module
VB.NET Create PDF from Excel Library to convert xlsx, xls to PDF
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. Convert to PDF with embedded fonts or without original fonts fast.
convert word doc to fillable pdf form; change font size in fillable pdf form
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
Convert OpenOffice Text Document to PDF with embedded Create PDF document from OpenOffice Presentation in both ODT, ODS, ODP forms to fillable PDF formats in
pdf fill form; convert pdf form fillable
24   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
In embracing “Proudly Found Elsewhere,” info files in Drupal 8 are now simple 
YAML files—the same as those used by other languages and frameworks. The 
syntax is very similar (mostly : instead of = everywhere, and arrays are formatted 
slightly differently), and it remains very easy to read and write these files. The 
awkward files[] key is gone, in favor of the PSR-4 standard for automatic 
class autoloading via Composer. The English version of that sentence is that 
by following a specific class naming/folder convention (modules/example/src/ 
ExampleClass.php), Drupal can pick up OO code automatically without requiring 
manual registration.
Drupal 7: hook_menu()
example.module
<?php
/**
* Implements hook_menu().
*/
function example_menu() {
$items[‘hello’] = array(
‘title’ => ‘Hello world’,
‘page callback’ => ‘_example_page’,
‘access callback’ => ‘user_access’,
‘access arguments’ => ‘access content’,
‘type’ => MENU_CALLBACK,
);
return $items;
}
/**
* Page callback: greets the user.
*/
function _example_page() {
return array(‘#markup’ => t(‘Hello world.’));
}
?>
This is a pretty basic “hello world” module in Drupal 7, which defines a URL at  
/hello that when accessed checks to make sure the user has “access content” 
permissions before firing the code inside _example_page() which prints “Hello 
world.” to the screen as a fully themed page. The hook_menu() is an example 
of what is pejoratively known as an “ArrayPI,” a common pattern in Drupal 7 and 
earlier. The problem with ArrayPIs is that they are difficult to type (for example, 
have you ever forgotten the return $items and then spent the next 30 minutes 
troubleshooting a problem?), have no IDE autocompletion for what properties are 
available, and the documentation must be manually updated as keys are changed 
and added. The documentation for hook_menu() shows that it also suffers from 
trying to do too many things. It’s used for registering path-to-page/access callback 
mappings, but it’s also used to expose links in the UI in a variety of ways: swapping 
out the active theme, and much more.
Drupal 8: Routes + Controllers
example.routing.yml
example.hello:
path: ‘/hello’
defaults:
_content: ‘\Drupal\example\Controller\Hello::content’
requirements:
_permission: ‘access content’
src/Controller/Hello.php
<?php
namespace Drupal\example\Controller;
use Drupal\Core\Controller\ControllerBase;
/**
* Greets the user.
*/
class Hello extends ControllerBase {
public function content() {
return array(‘#markup’ => $this->t(‘Hello world.’));
}
}
?>
C# PDF Field Edit Library: insert, delete, update pdf form field
A professional PDF form creator supports to create fillable PDF form in C#.NET. An advanced PDF form maker allows users to create editable PDF form in C#.NET.
convert pdf fillable form to word; create a pdf form that can be filled out
C# Create PDF from Excel Library to convert xlsx, xls to PDF in C#
Create fillable and editable PDF documents from Excel in both .NET WinForms and ASP.NET. Create searchable and scanned PDF files from Excel. Convert to PDF with
pdf form fill; create fillable form from pdf
25   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
In Drupal 8’s new routing system , the path-to-page/access-check logic now 
lives in a YAML file using the same syntax as the Symfony routing system . The 
page callback logic now lives in a “Controller” class (as in the standard model-
view-controller pattern) in a specially named folder, per the PSR-4 standard. It’s 
declared in the example module’s namespace to allow the example module to name 
its classes whatever it wants without worry of conflicting with other modules that 
might also want to say Hello (Drupal is very friendly, so it’s possible!). And finally, 
the class pulls in the logic from the ControllerBase class in via the use statement 
and extends it, which gives the Hello controller access to all ControllerBase’s 
convenient methods and capabilities, such as $this->t() (the OO way of calling the t() 
function). And, because ControllerBase is a standard PHP class, all its methods and 
properties will autocomplete in IDEs, so you aren’t guessing at what it can and can’t 
do for you.
Drupal 7: hook_block_X() 
block.module
<?php
/**
* Implements hook_block_info().
*/
function example_block_info() {
$blocks[‘example’] = array(
‘info’ => t(‘Example block’),
);
return $blocks;
}
/**
* Implements hook_block_view().
*/
function example_block_view($delta = ‘’) {
$block = array();
switch ($delta) {
case ‘example’:
$block[‘subject’] = t(‘Example block’);
$block[‘content’] = array(
‘hello’ => array(
‘#markup’ => t(‘Hello world’),
),
);
break;
}
return $block;
}
?>
Here’s an example of a typical way in which you define “pluggable thingies” in 
Drupal (blocks, image effects, text formats, and so on): some kind of _info() 
hook, along with one or more other hooks to perform additional actions (view, 
apply, configure, and more). In addition to these largely being ArrayPIs, this time 
they’re actually even worse “mystery meat” APIs, because the overall API itself is 
completely undiscoverable except by very careful inspection of various modules’  
.api.php files (provided they exist, which is not a guarantee) to discover which 
magically named hooks you need to define to implement this or that behavior. 
Some are required, some aren’t. Can you guess which is which?
Drupal 8: Blocks (and many other things) as Plugins
In Drupal 8, these “mystery meat” APIs have now largely been replaced by the new 
Plugin system, which looks something like this:
src/Plugin/Block/Example.php
<?php
namespace Drupal\example\Plugin\Block;
use Drupal\Core\Block\BlockBase;
/**
* Provides the Example block.
*
* @Block(
* id = “example”,
* admin_label = @Translation(“Example block”)
* )
*/
class Example extends BlockBase {
public function build() {
return array(‘hello’ => array(
‘#markup’ => $this->t(‘Hello world.’)
));
}
}
?>
C# Create PDF from Word Library to convert docx, doc to PDF in C#.
Convert multiple pages Word to fillable and editable PDF documents in both .NET WinForms and ASP.NET. Convert both DOC and DOCX formats to PDF files.
create pdf fill in form; convert pdf into fillable form
C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF
Convert multiple pages PowerPoint to fillable and editable PDF documents. Easy to create searchable and scanned PDF files from PowerPoint.
create fillable forms in pdf; form pdf fillable
26   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Most of this is very similar to the Controller example; a plugin is a class that in this 
case extends from a base class (BlockBase) that takes care of some underlying 
things for you. The Block API itself is housed in the BlockPluginInterface, which 
the BlockBase class implements.
Note that interfaces in general expose and document various APIs in a 
discoverable and IDE-friendly way. A great way to learn about the new APIs in 
Drupal 8 is by browsing through the interfaces that are provided.
The comments above the class are called annotations. At first it might seem 
strange for PHP comments to be used for specifying metadata that affects the 
logic of the software, but this technique is now widely used by many modern PHP 
libraries and accepted by the PHP community. Its benefit is that it keeps the class 
metadata in the same file as and right next to the class definition.
Drupal 7: Hooks
In Drupal 7 and earlier, the extension mechanism used is the concept of  
hooks. As an API author, you can declare a hook using functions like  
module_invoke_all(), module_implements(), drupal_alter(),  
and so on. For example:
<?php 
// Compile a list of permissions from all modules for 
// display on admin form. 
foreach (module_implements(‘permission’) as $module) { 
$modules[$module] = $module_info[$module][‘name’]; 
?>
If you wanted a module to respond to this event, you would create a function 
named modulename_hookname(), and declare its output in a way that the hook 
implementation expected. For example:
<?php 
/** 
* Implements hook_permission(). 
*/ 
function menu_permission() { 
return array( 
‘administer menu’ => array( 
‘title’ => t(‘Administer menus and menu items’), 
), 
); 
?>
Although this is a clever extension hack that is mostly the result of Drupal’s age 
(from back in 2001 when Drupal was new and when there was little support for OO 
code in PHP3), there are several tricky bits:
Ž
This “name a function in a special way” extension mechanism is very much a 
Drupalism, and developers coming to Drupal struggle to understand it at first. 
Ž
At least four different functions can trigger a hook: module_invoke(), module_
invoke_all(), module_implements(), drupal_alter(), and more. This makes 
finding all the available extension points in Drupal very difficult. 
Ž
There is no consistency between what various hooks expect. Some are 
info style hooks that want an array (sometimes an array of arrays of arrays 
of arrays), others are info-style hooks that respond when a particular thing 
happens like cron run or a node is saved. You need to read the documentation 
of each hook to understand what input and output it expects.
C# Create PDF Library SDK to convert PDF from other file formats
Create fillable PDF document with fields. Load PDF from existing documents and image in SQL server. Load PDF from stream programmatically.
convert pdf to fillable pdf form; change font pdf fillable form
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
Link: Edit URL. Bookmark: Edit Bookmark. Metadata: Edit, Delete Metadata. Form Process. ' odt convert to pdf Dim odt As ODTDocument = New ODTDocument("C:\1.odt
convert word document to pdf fillable form; convert pdf file to fillable form online
27   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Drupal 8: Events
Although hooks are definitely still prevalent in Drupal 8 for most event-driven 
behavior (though info-style hooks have largely moved to YAML or Plugin 
annotations), the portions of Drupal 8 that are more closely aligned to Symfony (for 
example, bootstrap/exit, routing system) as well as brand new code in Drupal 8 
like Migrate have largely moved to Symfony’s Event Dispatcher system . In this 
system, events are dispatched at runtime when certain logic occurs, and modules 
can subscribe classes to the events to which they want to react.
To demonstrate this, let’s take a look at Drupal 8’s configuration API, located 
in core/lib/Drupal/Core/Config/Config.php. It defines a variety of CRUD 
methods such as save(), delete(), and so on. Each method dispatches an event 
when finished with its work, so other modules can react. For example, here’s 
Config::save():
<?php
public function save() {
// <snip>Validate the incoming information.</snip>
// Save data to Drupal, then tell other modules this was
// just done so they can react.
$this->storage->write($this->name, $this->data);
// ConfigCrudEvent is a class that extends from Symfony’s
// “Event” base class.
$this->eventDispatcher->dispatch(ConfigEvents::SAVE, new
ConfigCrudEvent($this));
}
?>
As it turns out, at least one module needs to react when the configuration is saved: 
the core Language module. Because if the configuration setting that was just 
changed was the default site language, it needs to clear out compiled PHP files so 
the change can take effect.
To do this, Language module does three things:
1.  Registers an event subscriber class in its language.services.yml file (this  
is a configuration file for the Symfony Service Container for registering 
reusable code): 
language.config_subscriber:
class: Drupal\language\EventSubscriber\ConfigSubscriber
tags:
- { name: event_subscriber }
2.  In the referenced class, it implements the EventSubscriberInterface and 
declares a getSubscribedEvents() method, which itemizes the events that it 
should be alerted to and provides each with one or more callbacks that should 
be triggered when the event happens, along with a “weight” to ensure certain 
modules that need to can get the first/last crack at the object can (heads-up: 
Symfony’s priority scoring is the opposite of Drupal’s weight system—higher-
numbered methods are called first): 
<?php
class ConfigSubscriber implements EventSubscriberInterface {
static function getSubscribedEvents() {
$events[ConfigEvents::SAVE][] = array(‘onConfigSave’, 0);
return $events;
}
}
?>
3.  Defines the callback method, which contains the logic that should happen when 
the configuration is saved: 
<?php
public function onConfigSave(ConfigCrudEvent $event) { 
$saved_config = $event->getConfig(); 
if ($saved_config->getName() == ‘system.site’ && 
$event- >isChanged(‘langcode’)) { 
// Trigger a container rebuild on the next request. 
PhpStorageFactory::get(‘service_container’)
->deleteAl();
}
}
?>
28   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Overall, this buys us a more explicit registration utility so that a single module can 
subscribe multiple classes to individual events. This allows us to avoid situations 
in the past where we had switch statements in hooks or multiple unrelated sets of 
logic competing for the developer’s attention in a single code block. Instead, this 
provides the ability to separate logic into separate and distinct classes. This also 
means that our event logic is lazy loaded when it needs to be executed, not just 
sitting in PHP’s memory at all times.
Debugging events and finding their implementations is also pretty straightforward. 
Instead of a handful of procedural PHP functions that may or may not have 
been used to call your hook, the same Event Dispatcher is used throughout the 
system. In addition to this, finding implementations is as simple as grepping for the 
appropriate Class Constant, for example, ConfigEvents::SAVE.
Logically, the event system rounds out the transition to an OO approach. Plugins 
handle info-style hooks and hooks that were called subsequent to an info hook. 
YAML takes the place of many of our explicit registration systems of old, and the 
event system covers event-style hooks and introduces a powerful subscription 
methodology for extending portions of Drupal core. 
...and much, much more!
You can find a great introduction to Drupal 8’s API changes at the revamped  
D8 landing page of api.drupal.org where you’ll find a list of grouped topics to 
orient you to Drupal 8.
29   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
You can also see https://drupal.org/list-changes for the full list of API changes 
between Drupal 7 and Drupal 8. Each API change record includes before/
after code examples to help you migrate, as well as pointers to which issue(s) 
introduced the change and why.
So Much Typing
It’s true that moving to modern, OO code generally involves more verbosity than 
procedural code. To help you over the hurdles, check out the following projects:
Ž
Drupal Module Upgrader: If you’re looking to port your modules from Drupal 
7 to Drupal 8, look no further than this project. It can either tell you what you 
need to change (with pointers to the relevant change notices) or automatically 
convert your code in-place to Drupal 8. You can learn more about DMU in this 
podcast interview with the maintainer.
Ž
Console: For new modules, this project is a Drupal 8 scaffolding code 
generator that will automatically generate .module/.info files, PSR-4 directory 
structures, YAML, and class registrations for routes, and more! Learn more 
about the Drupal Console in this webinar with Jesus Olivas. 
Ž
Most Drupal 8 core developers swear by the PhpStorm IDE, and the latest 
version has lots of great features for Drupal developers . If you’re one of 
the top contributors to the Drupal ecosystem, you can get it for free! (Note 
that this isn’t product placement. You should join #drupal-contribute at any 
time of the day or night and see if you can go longer than an hour without 
someone mentioning PhpStorm.
30   THE ULTIMATE GUIDE TO DRUPAL 8, REVISED AND UPDATED FOR DRUPAL 8.1
Your Burning Questions
When should I start using Drupal 8? What do I need to do to upgrade? I have so 
many questions.
Why Should I Care about Drupal 8?
Drupal started first and foremost as a tool for developers and provided a set of 
APIs to allow building website elements in code, such as content entry forms, 
admin pages, and sidebar blocks. In later releases of Drupal, and particularly in 
Drupal 7, the emphasis was on making Drupal approachable for less technical 
users, providing user interfaces for foundational tasks (installation, data modeling, 
information architecture, landing pages, and so on). Most Drupal sites today 
download and configure a number of contributed projects for features such 
as a WYSIWYG editor, Views, and so on. And with that combination of core + 
contributed functionality, Drupal runs some of the biggest and most important 
sites on the web.
Drupal 8 builds on the success of Drupal 7’s approach by incorporating more 
expected “product” functionality out-of-the-box, such as authoring experience 
improvements, complete multilingual functionality, and numerous site builder 
features. Drupal 8 is more in line with the web landscape of today, with its mobile-
first approach and revamped front end. And, true to its developer roots, it offers 
numerous back-end features and modernized, OO code base. All around, Drupal 
8 is a more powerful release with capabilities for content authors, site builders, 
developers, and designers alike. It is built in a flexible, future-friendly way so that it 
can act as a solid foundation for projects no matter what technologies, devices, or 
services come out next. That said, Drupal 7 is still a stable, robust, fully-featured, 
and mature platform that will be supported for several more years to come. And 
much of the functionality within Drupal 8 is available in some form in Drupal 7 (see 
more details below).
How does Drupal’s release cycle work now?
Starting with Drupal 8.0.0, the Drupal project has moved to a new release cycle, 
which in addition to standard monthly bug fix and security releases (8.0.1, 8.0.2...) 
introduces semi-annual minor releases of core (8.1.0, 8.2.0, and so on). These 
releases can include new features, backward-compatible API improvements, and 
more. After several minor versions, a “Long-Term Support” (LTS) release of Drupal 
8 will be created and Drupal 9 development will begin. 
This means Drupalistas will no longer have to wait years for new core functionality; 
we can iterate on features and APIs every few months until the platform reaches 
maturity. It also means that those who are more risk-averse and want stability over 
shiny things can stick to LTS releases and only move every several years (even 
leap-frogging major versions). Hooray!
Documents you may be interested
Documents you may be interested