Platform.ly review

Plaform.ly is a powerful all in one marketing tool designed for startups and medium size businesses. It has the chops to compete with some of the larger foundations such as Mailchimp and Active Campaign.

Platform.ly is an excellent automation tool with lots of advanced marketing features. We use it to get real-time dashboard data, growth management, and user interaction tracking. With Platform.ly, we can save several hours of work each week, and use this valuable time to focus on spending time with our clients and further growing our agency.

Top 10 CMS Alternatives to WordPress

WordPress has spread its tentacles all over the web. Today, it powers more than 50% of all websites using a CMS and 22% of new U.S.-registered domain names run on it. What has made WordPress so popular is its flexibility—it is not limited to only powering a blog or news site, instead, thanks to a countless number of plugins and themes, it can be customized for e-commerce, business, community, and several other vertical-specific websites.

Many people swear by WordPress because of its unrivaled popularity. However, because it is popular doesn’t necessarily mean it is ideal for everything. WordPress can become bloated and overly complicated for small-scale sites; on the other hand, for complex websites, it may require way so much customization and so many tweaks that it is pushed to its limits. There are many WordPress alternatives that may better suit your website’s needs. Don’t always limit yourself to WordPress; explore the alternatives and evaluate those against your requirements.

This month’s article takes a look at 10 CMS alternatives to WordPress.

Ghost

Ghost is a simple yet powerful publishing platform that allows you to write and publish your own blog, providing the tools to make it easy and even fun to do. Unlike WordPress, which has evolved more as a CMS for creating any type of website, Ghost aims at being a blog platform. Ghost is based on Node.js, which makes it fast, scalable, and efficient.

Instant Update

Instant Update is a revolutionary CMS in that it is not based on templates and it integrates into any existing website in just a few minutes. All you need is a series of flat HTML pages to upload to Instant Update to allow on-the-fly editing of any HTML elements on the page. You can also set ‘Global Content’ for your headers and footers so that updates are automatically reflected sitewide.

concrete5

concrete5 is a free open source content management system. Unlike other CMSs, it has a strong focus on the editing experience thanks to its powerful in-page editing functionality; just click on what you want to change. For developers, concrete5 is packed with customization flexibility—it sports an advanced permission system, flexible data object models, and built-in helper classes as well. concrete5 can be used to build and manage simple blogs, complex online magazine and e-commerce sites, and everything in between.

ExpressionEngine

ExpressionEngine is a flexible, feature-rich content management platform that empowers hundreds of thousands of individuals and organizations around the world to easily manage their websites. It is based on the popular open source CodeIgniter framework. Its forte is its security and stability; in the past 10 years, ExpressionEngine has never had a major security breach. The only caveat is that ExpressionEngine is a commercial application selling at $299 per site license.

PyroCMS

PyroCMS is used by individuals, small and medium-sized businesses, and large organizations worldwide to easily create and build a variety of websites and web-enabled applications. With an ever-growing community and a large selection of modules, themes, and addons, PyroCMS makes it easier than ever to build your website!

Statamic

Statamic is a flat-file and lightweight CMS built on PHP. It supports a flexible theme engine, taxonomies (for defining your custom content types), a forum builder (with validation and email notifications), and a powerful search feature. Statamic is a commercial application with a personal license starting at $29 per site.

HiFi

HiFi is a ground-breaking hosted content management platform. It allows you to design beautiful websites with web standards and zero design constraints. Users will be able to manage every aspect of their websites using easy-to-use tools.

Zotonic

Zotonic is an open source, high speed, real-time web framework and content management system built with Erlang. It is flexible, extensible, and designed from the ground up to support dynamic, interactive websites and mobile solutions. Zotonic is incredibly fast and wonderfully stable—suited for everything from basic websites to complex distributed applications. It offers an elegant backend for managing content with the flexibility that developers need to build truly amazing applications.

Craft

Craft is content management at its finest. It delivers an extraordinary amount of control to developers, while keeping the editing experience simple and elegant for end users. Some of its features includes live preview, multilingual support, custom fields, section types, and one-click updates.

Drupal

Drupal is a free open source CMS written in PHP. It is used to build personal blogs and corporate and government websites. The standard release of Drupal, known as Drupal Core, contains basic features common to content management systems. These include user account registration and maintenance, menu management, RSS feeds, page layout customization, and system administration. Similar to WordPress, Drupal can be extended through modules—more than 21,500 different modules are available in the Drupal repository.

Developing State-enabled Applications With PHP

When a user is browsing through a website and is surfing from one web page to another, sometimes the website needs to remember the actions (e.g. choices) performed by the user. For example, in a website that sells DVDs, the user typically browses through a list of DVDs and selects individual DVDs for check out at the end of the shopping session. The website needs to remember which DVDs the user has selected because the selected items needs to be presented again to the user when the user checks out. In other words, the website needs to remember the State – i.e. the selected items – of the user’s browsing activities. However, HTTP is a Stateless protocol and is ill-equipped to handle States. A standard HTML website basically provides information to the user and a series of links that simply directs the user to other related web pages. This Stateless nature of HTTP allows the website to be replicated across many servers for load balancing purposes. A major drawback is that while browsing from one page to another, the website does not remember the State of the browsing session. This make interactivity almost impossible.In order to increase interactivity, the developer can use the session handling features of PHP to augment the features of HTTP in order to remember the State of the browsing session. The are basically 2 ways PHP does this:

– Using cookies
– Using Sessions

The next installment discusses how to manage sessions using cookies…

Cookies

Cookies are used to store State-information in the browser. Browsers are allowed to keep up to 20 cookies for each domain and the values stored in the cookie cannot exceed 4 KB. If more than 20 cookies are created by the website, only the latest 20 are stored. Cookies are only suitable in instances that do not require complex session communications and are not favoured by some developers because of privacy issues. Furthermore, some users disable support for cookies at their browsers.

– The following is a typical server-browser sequence of events that occur when a cookie is used:
– The server knows that it needs to remember the State of browsing session
– The server creates a cookie and uses the Set-Cookie header field in the HTTP response to pass the cookie to the browser
– The browser reads the cookie field in the HTTP response and stores the cookie
– This cookie information is passed along future browser-server communications and can be used in the PHP scripts as a variable

PHP provides a function called setcookie() to allow easy creation of cookies. The syntax for setcookie is:

int setcookie(string name, [string val], [int expiration_date], [string path], string domain, [int secure])

The parameters are:

name – this is a mandatory parameter and is used subsequently to identify the cookie
value – the value of the cookie – e.g. if the cookie is used to store the name of the user, the value parameter will store the actual name – e.g. John
expiration_date – the lifetime of the cookie. After this date, the cookie expires and is unusable
path – the path refers to the URL from which the cookie is valid and allowed
domain – the domain the created the cookie and is allowed to read the contents of the cookie
secure – specifies if the cookie can be sent only through a secure connection – e.g. SSL enable sessions

The following is an example that displays to the user how many times a specific web page has been displayed to the user. Copy the code below (both the php and the html) into a file with the .php extension and test it out.

<?php
 //check if the $count variable has been associated with the count cookie
 if (!isset($count)) {
 $count = 0;
 } else {
 $count++;
 }
 setcookie(“count”, $count, time()+600, “/”, “”, 0);
 ?>

<html>
 <head>
 <title>Session Handling Using Cookies</title>
 </head>
 <body>
 This page has been displayed: <?=$count ?> times.
 </body>
 </html>

The next installment discusses how to manage sessions using PHP session handling functions with cookies enabled…

PHP Session Handling – Cookies Enabled

Instead of storing session information at the browser through the use of cookies, the information can instead be stored at the server in session files. One session file is created and maintained for each user session. For example, if there are three concurrent users browsing the website, three session files will be created and maintained – one for each user. The session files are deleted if the session is explicitly closed by the PHP script or by a daemon garbage collection process provided by PHP. Good programming practice would call for sessions to be closed explicitly in the script.

The following is a typical server-browser sequence of events that occur when a PHP session handling is used:
The server knows that it needs to remember the State of browsing session
PHP generates a sssion ID and creates a session file to store future information as required by subsequent pages
A cookie is generated wih the session ID at the browser
This cookie that stores the session ID is transparently and automatically sent to the server for all subsequent requests to the server

The following PHP session-handling example accomplishes the same outcome as the previous cookie example. Copy the code below (both the php and the html) into a file with the .php extension and test it out.

<?php
 //starts a session
 session_start();

//informs PHP that count information needs to be remembered in the session file
 if (!session_is_registered(“count”)) {
 session_register(“count”);
 $count = 0; } else {
 $count++;
 }
 $session_id = session_id(); ?>

<html>
 <head>
 <title>PHP Session Handling – Cookie-Enabled</title>
 </head>
 <body>
 The current session id is: <?=$session_id ?>
 This page has been displayed: <?=$count ?> times.
 </body>
 </html>

A summary of the functions that PHP provides for session handling are:

boolean start_session() – initializes a session
 string session_id([string id]) – either returns the current session id or specify the session id to be used when the session is created
 boolean session_register(mixed name [, mixed …]) – registers variables to be stored in the session file. Each parameter passed in the function is a separate variable
 boolean session_is_registered(string variable_name) – checks if a variable has been previously registered to be stored in the session file
 session_unregister(string varriable_name) – unregisters a variable from the session file. Unregistered variables are no longer valid for reference in the session.
 session_unset() – unsets all session variables. It is important to note that all the variables remain registered.
 boolean session_destroy() – destroys the session. This is opposite of the start_session function.

The next installment discusses how to manage sessions using PHP session handling functions when cookies are disabled…

PHP Session Handling – Without Cookies

If cookies are disabled at the browser, the above example cannot work. This is because although the session file that stores all the variables is kept at the server, a cookie is still needed at the browser to store the session ID that is used to identify the session and its associated session file. The most common way around this would be to explicitly pass the session ID back to the server from the browser as a query parameter in the URL.

For example, the PHP script generates requests subsequent to the start_session call in the following format:

http://www.yourhost.com/yourphpfile.php?PHPSESSID=[actual session ID]

The following are excerpts that illustrate the discussion:

Manually building the URL:

$url = “http://www.yoursite.com/yourphppage.php?PHPSESSID=” . session_id();
 <a href=”<?=$url ?>”>Anchor Text</a>

Building the URL using SID:

<a href=”http://www.yoursite.com/yourphppage.php?<?=SID ?>”>Anchor Text</a>

A deeper look into Perl array variables

An array is a list of elements, think of it as a collection of scalars combined to one name. Though it’s primary use is being called with @, it shares with scalars and hashes the symbol $. Afterall, an array is a bunch of scalars linked together.
Array assignments/creation:

To make an array, we set it as @array = (); Like with scalars and hashes, the name following the variable sign ($ or @) can be virtually any name you like if it starts with an alpha character. An example of an array would be:

my @numbers = (1,2,3);

An array can be any length (as long as you have enough virtual memory), but it wouldn’t make much sense using one value when instead a scalar would work just fine.

To print an entire array, we would do something like this:

my @numbers = (1,2,3);
print @numbers;

How to print an array

The result of this print would be 123. Note there aren’t any spaces between keys. There are a number of ways to get around this, one of them is using quotes around the array elements and tacking a blank space at the end.

my @numbers = (“1 “, “2 “, “3 “);
print @numbers;

The result of our new print would be 1 2 3. Probably the result you’d prefer if you’re planning on storing crucial bits of information such as names and phone numbers. You can always use quotes around each of your elements, in most cases it’s required.  For confusion purposes, pretend quotes are always requried and use them around each and every single element in your list.

Now that we know how to create and print an entire array, let’s go a little deeper and take a look at some its powerful features. An easier way to do this would be to print an array inside quotes. This interprets the array as a list rather than a single line with a bunch of data.

print “@numbers”;

Using the same values as above, this would print 1 2 3. Even though this method works, it won’t work well enough to be practical in most instances. Later on you’ll see why when we discuss how to sort arrays. In this example, we are using the join function on the array @numbers and adding a blank space between each element in the list.

print join( ” “, sort @numbers);

Let’s say we don’t want to print the entire array, if we had a list of 20,000 elements and we only wanted one, why would we? You can print any element you want, afterall each of them are scalars (or more percisely can be used as scalars). Using our previous examples of “1″ “2″ “3″, let’s say we wanted to print out the number 2.

print $numbers[1];

Perl, like most languages, begin their numbering system at zero so of the three elements we have, the results would be [0] = 1, [1] = 2, [2] = 3. To print a single element, we must treat it as a single element and use it’s scalar sign $.

What would we do if we didn’t know how many elements our array held and wanted to print just the last one? There are two ways we can go about doing this, the simplest way being print $numbers[-1]. We will be going over the other method shortly when we get into POP.

More array assignments

You can add to an array by assigning another value. You want to be careful when doing this to be sure your number isn’t overwriting some of your data.

$numbers[3] = “4″;

Now our @numbers contains the numbers 1, 2, 3, 4. Our [3] represents the fouth digit (counting from zero as being one) and we added another number to our list. You could, for the sake of doing it, assign it so high it leaves all unused positions undefined. Not that it’s recommended as there really isn’t a logical purpose that I can imagen, it uses more bandwith and decreases the speed if the number is high enough, but for the curious you could do something like:

$numbers[999999] = “5″;

We now have 999996 undefined values because the array had to build enough room for 9999999. Again, this shouldn’t be done for real life applications, but you can have fun with it and see how it affects the speed of your scripts.
Pop and Push

POP and PUSH are methods we use to add or remove the last element of our array. If during a print out of your array and for some reason you notice the last element isn’t needed or if you want to remove it so you can work with it more specifically, you would use POP. This ‘pops’ the last element from the list.

my @numbers = (“1″, “2″, “3″);
pop(@numbers);

Now all we have left is 1 and 2, our friend 3 got pushed off and will never be seen again. If you wanted to use this, maybe you wanted to print this before discarding it.

my $lastnumber = pop(@numbers);

You can do whatever you want with “3″ now, you can print it, forget about it, change it’s value and push it back in, etc. The method push is the counterpart of pop. This is how you add information to the end of everything. Sometimes we don’t want to add things to the beginning of our arrays (because they print in left to right, top to bottom, order.) Let’s say we want to add the 3 we just removed back into our list.

push(@array, “3″);

Now 1, 2 and 3 are friends again though 3 might be a little confused or mad that you got rid of him in the first place. No matter how many items you have in your array, this will put it at the end (which we could call using $numbers[-1] like we discussed earlier).
Shift and Unshift

Push and Pop work at the end of your list, similarily shift and unshift work at the beginning. Shift works like push did as this adds more data. Let’s add the number 0.

unshift(@numbers, “0″);

Our array of numbers contains the numbers 0, 1, 2 and 3 now. As you probably have guessed it already, unshift will remove the first object in your list. 0 was a trouble maker and didn’t get along with our dear friends 1, 2 or 3, so let’s do them a favor and get rid of 0 for them.

shift(@numbers);

We are now back to 1, 2 and 3 again. You can store the unshifted data into a variable if you want by assigning a scalar to it:

my $firstitem = shift(@numbers);

Reversing an array

Perl has a very nice reverse feature letting us simply reversing the printing order of the array. We are getting sick and tired of our prints coming out as “123″, so let’s reverse it.

print (reverse @numbers);

Using 1,2,3 as our array, we would get a print back of 321. As we went over before, this format isn’t very useful for every day applications. We need to be able to present the data in a useable manner, so to add spaces between elements we’ll be using split again.

print join(” “, reverse @numbers);

Counting indexes or entries

$#array returns the number of indexes or in the array. This is a useful way in dermining the last valid index in the array if you had something to push onto the end of it. We will be discussing the push functions in a later section, all you need to know right now is how to calculate the last index.

my @cookies (“chocolate chip “, “peanut butter “, “oreo”);
print $#cookies;

Many times in our scripts we would like to view just the last one or two (or few) pieces of information. You already learned how to use $index[] to assign more data into the array, so this concept shouldn’t be very new to you. If you begin index with a positive number, it starts at the beginning of the list. Using a negative index starts from the end of the list and moves backwards.

my @planets = (“mercury”, “mars”, “earth”, “saturn”, “pluto”, “marsian’s homeland”);
print $planets[0];
print $planets[-1];

The first print will bring back “mercury” as it’s index[0]. index[-1] is the very last element in the list and in our case, it will print “marsian’s homeland”. If you wanted to view the 2nd to the last element, you would use [-2], or for the third [-3] and so on.

To better help you understand indexes, run the code from the bottom of the page called ‘indexes’..

The result of the print would be 2 because we have three items (item or index 0, 1, 2). If instead you wanted to find the number of elements in the list rather than worrying about indexes, scalar is the function we’d use. Scalar takes any expression and returns the scalar value. Since we are using it on a list @cookies, it returns the number of array entries you have.

my @planets = (“mercury”, “mars”, “earth”, “saturn”, “pluto”, “marsian’s homeland”);
print $planets[0];
print $planets[-1];

scalar @cookies;
Merging

Your company just merged with another firm down the street and you want one large list of employees rather than two separate lists. This can be a fairly common task and in Perl it’s quite simple to merge two or more arrays to combine one, larger array.

my @employees1 = (“Fred Flintstone”, “Barny Rubble”, “Dino Fintstone”);
my @employees2 = (“Wilma Flintson”, “Bamm-Bamm”, “Jigglypuff”);
my @allemployees = (@employees1, @employees2);

@allemployees now contains all the names from employees1 and employees2 with employees1′s data first. If you want the second sent of employees to appear on top, all you have to do is change the assignment order to = (@employees2, @employees1);


Array splicing

Perl enables us to be able to remove (and optionally return) more than one element at a time. We can do this using array splices. A splice takes a list, an offset and a lenth.

splice (@array, offset, length);

The offset is an integer where you want the splicing to begin. You use array indexing again (isn’t it remarkable how often these indexes come up?). The length is also a whole number and this is how many indexes you want to splice.

my @colors = (“red”, “blue”, “orange”, “purple”, “pink”, “white”); splice(@colors, 0, 2);
print @colors;

We set the offset at 0, which is the 0 index red and the length of 2 . This will remove the first three sets of information from the list leaving purple, pink and white left. If we spliced (@colors, 2, 1), we would be removing the index[2] (orange). Since our length is only 1, we’re only removing one index.


Sorting

Printing a list of 100,000 names would be a mess if we couldn’t sort the list, wouldn’t it? You’d have names or phone numbers or dates in insertion order rather than a user-friendly alphabetical or numerical order. Luckily for us, Perl makes it simple for us to sort an entire list alphabetically.

my @animals = (“frog”, “toad”, “snake”, “grasshopper”, “bird”);
print join(” “, sort @animals);

sort (@array) will take the array and put it in alpha-numerical order for you. Using sort(@array) on our animals, we would get back : bird, frog, grasshopper, snake, toad. If we had numbers (“1″, “3″, “5″) in with our animals, the numbers would print before the animals.
Deleting

Sometimes you will want to remove a certain element from your list. This can be done using delete. To remove a single piece of information we need to treat the list as a scalar.

my @animals = (“frog”, “toad”, “snake”);
delete $animals[0];

Oh oh, it appears our newest pet frog was eaten by a snake in our garden. It’s a very sad tragedy and we will mourn deeply for the rest of our lives, but to remove our dead frog’s memory we use the delete $array[index] command..

If instead you wanted to delete an entire array, the quickest way would be to assign it a null value. A null value is different than an undefined value, so don’t try @animals = undef; thinking it’ll delete your array. Instead, use:

@animals = ();

The toad and the snake ran away, that’s three animals we just lost. How ever are we going to live with ourselves? Between the tears you cry, we assign our list of animals to a blank list and we have nothing else to live for :( .

How Not to Script HTML Form Validation

Douglas Crockford has dubbed Javascript “the world’s most misunderstood programming language.” If he is correct, and I believe he is, then it should be no surprise that a good deal of Javascript development is tainted by “AntiPatterns”.

An AntiPattern quite simply is what does not work. Let’s consider what this means on a couple of different levels, within the context of validating form data with Javascript.

First lets consider specific code that “does not work”. Recent books have gotten better at avoiding the following sort of thing, but it remains widespread to this day (to keep this example as brief as possible I’m not including any code that would provide feedback to the user, such as a Javascript alert).

<form
onsubmit= ‘return this.fname.value != “” &amp;&amp; this.lname.value !=””‘>
First Name: <input type=”text” name=”fname”>
<br>
Last Name: <input type=”password” name=”lname”>
<br>
<input type=”submit” value=”Log In”>
</form>

If the user enters absolutely nothing into either fname or lname, the form’s onsubmit handler will return false and the form will not be submitted. The code successfully prevents submitting completely empty fields.

It does not however prevent the user from entering spaces into those fields. It is therefore not enough to test against the empty string “”.

The solution is to test against a “regular expression” object. For the uninitiated, “regex”’s, as they are also sometimes called, represent a pattern of characters. For the task at hand, we are going to use a very simple pattern: /\S/

The first thing to notice are the beginning and ending slashes. These simply signify that what’s between them is the expression, not unlike quotation marks signifying that they contain text.

Within the slashes, the pattern \S stands for any non-whitespace character. Regular expressions in Javascript have some useful built in methods, including test() , which returns true or false depending on whether a string passed as an argument matches the pattern.

So in the above example we can just switch the onsubmit event handler to the following, and it will not only reject completely empty fields, but also fields containing only whitespace, such as spaces:

onsubmit=’return /\S/.test(this.fname.value) &amp;&amp; /\S/.test(this.lname.value)’

Substituting the above, now both name fields must contain some non-whitespace characters in order for the form to get submitted. Following the colorful parlance for AntiPatterns, the erroneous example on page 1 might be called the “Out of Sight Out of Mind” AntiPattern. Except that AntiPatterns typically describe a problem that is more systemic, rather than one that can be so readily rectified by correcting one line of code. For instance, failure — or refusal — to use a language feature such as Regular Expressions.

Better yet exemplifying a bona fide AntiPattern in a Javascript form validation context is what I call the “All Web Development is New Development” fallacy. This antiPattern, like the code defect debunked in the first example, is commonplace both in books and in code libraries distributed all over the web.

“All Web Development is New Development” in the Javascript form validation context most often occurs through the suggestion that, to signify that form fields are required to be filled in, these required fields must be named in a certain manner. Users of such code are instructed to do such things as end the names of their form fields with “_req” .

So, in our first example, “fname” would become “fname_req” , and “lname” would become “lname_req” . To begin with, though, this violates one of Arthur J Riel’s Object-Oriented Design Heuristics, particularly 3.5, which states in part: “In applications which consist of an object-oriented model interacting with a user interface, the model should never be dependent on the interface.”

The HTML comprises the user interface. Now substitute “data” for “model” above. Data is required to specify one field as required, and another as not required. But by appending “_req” to the name of an HTML form element, the data becomes dependent on the interface.

Rules are made to be broken, but not in this instance. Because, although requiring that form field names have “_req” be appended to them might work in the case of a new web application, what about an existing web application? It almost certainly consists in part of server-side form processing code that relies on pre-determined form field names. Adding “_req” to those field names will almost certainly cause existing server-side code to malfunction.

Overview of XML encryption

XML encryption classifies a course of action for encrypting plain text data, generating ciphertext, and decrypting the ciphertext to retrieve the plaintext data.

Both the and are optional i.e. the sender and receiver may agree on the encryption method and key in advance. Several elements use the definitions from the DSIG.

If the recipient does not know the decryption key in advance, then the sender generates and sends it. The key can be protected in transit by encrypting method or key agreement.

If the plaintext data to encrypt is an XML element or content, you encode it using UTF-8 and perform any necessary transforms to it, otherwise, if it is an external resource, you simply consider it as an octet sequence. You then encrypt the data, creating CipherValue, which you place in EncryptedData.

Care must be taken when signing content that may later be encrypted; clearly; the content must be restored to exactly the original plaintext form for the signature to validate properly. To restore the plaintext in the signed content, use the decryption transform method for XML signature defined by the XML encrypt joint W3C and IETF working group.

This transform also allows specifications of XML fragments that were encrypted and then signed with rest of the document and, therefore, are not decrypted to validate the signature. Often, encrypted fragments are removed from the signed information by using the XPATH transform in the reference element, since the meaningful information is the plaintext.

We can sign the plaintext version of an encrypted element by including the appropriate reference element pointing to it. When the signed document is confidential and encrypted after being signed, you should also protect against surreptitious forwarding in which the recipient forwards the signed confidential document to a competitor, encrypted by the competitor public key, trying to make it look as if the sender sent the confidential information. To prevent surreptitious forwarding, the signer should append the recipient identities to the document being signed.

If the recipient does not know the decryption key in advance, then the sender generates and sends it. The key can be protected in transit by encrypting method or key agreement.

If the plaintext data to encrypt is an XML element or content, you encode it using UTF-8 and perform any necessary transforms to it, otherwise, if it is an external resource, you simply consider it as an octet sequence. You then encrypt the data, creating CipherValue, which you place in EncryptedData.

Care must be taken when signing content that may later be encrypted; clearly; the content must be restored to exactly the original plaintext form for the signature to validate properly. To restore the plaintext in the signed content, use the decryption transform method for XML signature defined by the XML encrypt joint W3C and IETF working group.

This transform also allows specifications of XML fragments that were encrypted and then signed with rest of the document and, therefore, are not decrypted to validate the signature. Often, encrypted fragments are removed from the signed information by using the XPATH transform in the reference element, since the meaningful information is the plaintext.

We can sign the plaintext version of an encrypted element by including the appropriate reference element pointing to it. When the signed document is confidential and encrypted after being signed, you should also protect against surreptitious forwarding in which the recipient forwards the signed confidential document to a competitor, encrypted by the competitor public key, trying to make it look as if the sender sent the confidential information. To prevent surreptitious forwarding, the signer should append the recipient identities to the document being signed.

Introduction to Perl Scripting

What is it?

Perl was one of the first computer languages every written, through it’s years of existance the contributers of the language have made it one of the the most robust and powerful languages there are. Perl is short for Practical Extraction Report Language, because that’s what it is. It creates and extracts data on the fly with remarkable speed.You will often times hear the words Perl and CGI together as if they’re one and the same. It’s safe to think this, as CGI is a module built for Perl, the main difference is CGI is typically OOP (object-oriented programming) while Perl itself usually is not. CGI is short for Common Gateway Interface which is a great name because it’s Perl’s interface to work on the web. For more on a definition of Perl, please check out this post by Web Hosting Dorks.

What does it do?

Since this is one of the fastest languages there are, this makes a great report processing and retrieval language. You can parse hundreds of thousands of lines of code from a text file in just a few seconds (I typically can get around 80,000 lines returned in a fraction of a second).

Some very common uses for Perl/CGI: Data extraction, encryption, contact forms, guestbooks, full ecommerce sites, web parsers and web bots, search engines, image manipulation, security.

What can’t it do?

It can do nearly anything you can think of when working in strictly Perl on your own computer. You can create graphics, setup password scripts, encrypt files, track users, etc. But on the web, it’s only limitation is the fact it’s a server-side language.

This means that the content created using Perl/CGI is not dymanic; all of it’s work is done at the time the page loads. This is unlike JavaScript which can have content change at any given time. A simple example of this would be a contact form. The fields can’t be checked or verified on the page that just loaded, the page has to reload or redirect before Perl/CGI can use this information.

What do I need?

If you want to run Perl scripts on your own computer and you’re on Windows or Mac, you’ll need to download ActiveState Perl. The link for this can be found in Tutorials section, be sure to always download the latest version. At the time of writing this article, the latest version is 5.8.6.

To use CGI, you’ll either need your own server or a server hosted by another company online. Your server or web host must allow CGI support. If it doesn’t, you will not be able to use web based Perl scripts. There are many free servers out there that do allow CGI and nearly all paid hosts will. CGI is a standard which makes finding a worthy host a much simpler task.

Getting Started with the MEAN Stack

A very popular JavaScript stack is the MEAN stack. It’ll let you do everything you could do with a LAMP stack, and you’ll only use JavaScript. This article has a compilation of useful resources that will help you get started with MEAN.

Introduction to the MEAN Stack Development

An Introduction To Full-Stack JavaScript

This Smashing Magazine article will give you an overview of why full-stack JavaScript might be right for you and how it works its magic.

Getting MEAN

This is a great 1-hour video from the Google development team that covers the basics of MEAN. It starts with an overview of MEAN from Valeri Karpov, who first coined the term, and throughout the video several other experts join in to explain the use of MEAN in both web and mobile enterprise environments.

Installing the MEAN stack

How to get started on the MEAN stack

This article will show you how to install the MEAN stack on your development box. The author has very detailed instructions on how to install the different required MEAN components for Windows, Linux, and Mac OS X.

Click-to-deploy MEAN development stack on Google Compute Engine

The Google Cloud Platform supports click-to-deploy for the MEAN development stack. This handy guide will show you how to get your MEAN development or test environment running quickly.

MEAN.io

This is a web framework with MongoDB, Express, AngularJS, and Node.js. It will help you get started and avoid useless grunt work and common pitfalls, while keeping your application organized.

Learning MongoDB

The MongoDB 2.6 Manual

The official MongoDB Manual, which introduces MongoDB and describes the query language, operational considerations and procedures, administration, application development patterns, and other aspects of MongoDB use and administration.

MongoDB Tutorial

This tutorial from Tutorials Point will give you a great understanding of the MongoDB concepts needed to create and deploy a highly scalable and performance-oriented database.

MongoDB Tools

Mongodb-tools.com has categorized collection of MongoDB tools. You’ll be able to find GUI, log analysis, and monitoring tools.

Learning Express

Official Express Site

The official site of Express has a great learning center with installation instructions, a guide, and API reference, as well as advanced topics. It also includes a resources section with links to books, blogs, community, and applications.

Creating a basic site with Node.js and Express

This is a walkthrough on how to create and deploy a basic site with Node.js and the Express framework.The walkthrough is aimed at beginners exploring Node.js.

Express.js Guide

This book is an in-depth, detailed, hands-on manual on Express.js. It will get you up and running fast and save you time.

Learning AngularJS

Video Tutorial: AngularJS Fundamentals in 60-ish Minutes

With this video you’ll learn how to get started with the AngularJS framework. You’ll also learn some of the key features that simplify Single Page Application development.

Introduction to Angular JS

This video will walk you through how to build a sample application with AngularJS in order to learn some of the basics. There is also some commentary that contrasts AngularJS with jQuery/Backbone.JS.

AngularJS-Learning

For a comprehensive and continually growing collection of links, check AngularJS-Learning, a GitHub repo that collects resources, links, and interesting blog posts.

Learning Node.js

The Beginner Node Book

This is an online, free, open source book on Node. Its great for people new to Node or to server-side JavaScript programming.

Node.js for Beginners

This is a great primer on Node.js. This article will teach you some of the basics of Node.js and explain why it has become so popular.

Learn All The Nodes

Learn All The Nodes is a screencast series that focuses on short demonstrations of useful tips and tricks for Node.js. All screencasts are meant to be manageable viewing experiences, something you can fit in during short breaks or during lunch and learns.

Node Tuts

Node Tuts is a screencast show of Node.js that will teach you some of the basics of Node.js, along with some advanced topics such as building a streaming TCP server or error handling.