Electron began in 2013 as the framework on which Atom, GitHub’s hackable text editor, would be built. The two were open sourced in the Spring of 2014.

It has since become a popular tool used by open source developers, startups, and established companies. See who is building on Electron.

Read on to learn more about the contributors and releases of Electron or get started building with Electron in the Quick Start Guide.

What does Processing bring to the web?
Processing has a large and vibrant community, who are good at creating 2D and 3D graphics, visualizing data sets, audio, video, etc. With HTML5 the web gained canvas, audio, and video–things which had previously only been available via plugins like Flash or Java. At the same time, advances in JavaScript engines have made it possible to do things in script that were previously too slow.

By porting the Processing language to the web, both the Processing and web communities benefit. For Processing, this means that code which used to only work on the desktop now “just works” in the browser. For the web, this means that a new but mature and full-featured approach to graphics programming becomes available. The < canvas > element is too low-level for most developers to use directly–JavaScript libraries are necessary. Processing.js can be thought of as just such a library, simplifying the use of the 2D and 3D canvas operations.

How much work is it to learn Processing?
The Processing language was designed to be small but complete, and easy to learn. This document does not attempt to teach you Processing, and you are encouraged to seek out Processing specific tutorials, books, and examples. Any Processing code or concepts should map to Processing.js (the exceptions are listed below). You can also use pure JavaScript to work with the Processing drawing API, skipping the Java syntax of Processing in favour of JavaScript.

Ways to Use Processing.js
Processing.js was originally created in order to allow existing Processing developers and existing Processing code (often referred to as sketches) to work unmodified on the web. As a result, the recommend way to use Processing.js is to write Processing code, and have Processing.js convert it to JavaScript before running it.

Over time, many web developers have begun using Processing.js, and asked that we design a way for the API to be used separate from the Processing language itself. Therefore, we have provided a way for JavaScript developers to write pure JavaScript code and still use the Processing.js functions and objects. NOTE: Processing.js is first and foremost a port of Processing to the open web, with design decisions favouring compatibility with Processing. It was not designed as a general purpose HTML drawing library. Having said that, it can be used as a high-level drawing API for canvas.

Below we discuss the various methods for using Processing.js in your web pages.

Writing Pure Processing Code
This is the preferred method for using Processing.js, and has been dealt with at length in the Processing.js for Processing Devs quick start guide. To summarize:

Download Processing.js from here

• Use the order of operations to simplify expressions, including those with parentheses.
• Use the order of operations to simplify expressions containing exponents and square roots.

Introduction

People need a common set of rules for performing computation. Many years ago, mathematicians developed a standard order of operations that tells you which calculations to make first in an expression with more than one operation. Without a standard procedure for making calculations, two people could get two different answers to the same problem. For example, 3 + 5 • 2 has only one correct answer. Is it 13 or 16?

The Order of Addition, Subtraction, Multiplication & Division Operations

First, consider expressions that include one or more of the arithmetic operations: addition, subtraction, multiplication, and division. The order of operations requires that all multiplication and division be performed first, going from left to right in the expression. The order in which you compute multiplication and division is determined by which one comes first, reading from left to right.

After multiplication and division has been completed, add or subtract in order from left to right. The order of addition and subtraction is also determined by which one comes first when reading from left to right.

Below, are three examples showing the proper order of operations for expressions with addition, subtraction, multiplication, and/or division.

Grouping Symbols and the Order of Operations

Grouping symbols such as parentheses ( ), brackets [ ], braces, and fraction bars can be used to further control the order of the four basic arithmetic operations. The rules of the order of operations require computation within grouping symbols to be completed first, even if you are adding or subtracting within the grouping symbols and you have multiplication outside the grouping symbols. After computing within the grouping symbols, divide or multiply from left to right and then subtract or add from left to right.

When there are grouping symbols within grouping symbols, compute from the inside to the outside. That is, begin simplifying the innermost grouping symbols first. Two examples are shown.

Remember that parentheses can also be used to show multiplication. In the example that follows, the parentheses are not a grouping symbol; they are a multiplication symbol. In this case, since the problem only has multiplication and division, we compute from left to right. Be careful to determine what parentheses mean in any given problem. Are they a grouping symbol or a multiplication sign?

Consider what happens if braces are added to the problem above: 6 ÷ {(3)(2)}. The parentheses still mean multiplication; the additional braces are a grouping symbol. According to the order of operations, compute what is inside the braces first. This problem is now evaluated as 6 ÷ 6 = 1. Notice that the braces caused the answer to change from 1 to 4.

Performing the Order of Operations with Exponents and Square Roots

So far, our rules allow us to simplify expressions that have multiplication, division, addition, subtraction or grouping symbols in them. What happens if a problem has exponents or square roots in it? We need to expand our order of operation rules to include exponents and square roots.

If the expression has exponents or square roots, they are to be performed after parentheses and other grouping symbols have been simplified and before any multiplication, division, subtraction and addition that are outside the parentheses or other grouping symbols.

Note that you compute from more complex operations to more basic operations. Addition and subtraction are the most basic of the operations. You probably learned these first. Multiplication and division, often thought of as repeated addition and subtraction, are more complex and come before addition and subtraction in the order of operations. Exponents and square roots are repeated multiplication and division, and because they’re even more complex, they are performed before multiplication and division. Some examples that show the order of operations involving exponents and square roots are shown below.

Some people use a saying to help them remember the order of operations. This saying is called PEMDAS or “Please Excuse My Dear Aunt Sally.” The first letter of each word begins with the same letter of an arithmetic operation.

Note: Even though multiplication comes before division in the saying, division could be performed first. Which is performed first, between multiplication and division, is determined by which comes first when reading from left to right. The same is true of addition and subtraction. Don’t let the saying confuse you about this!

Summary

The order of operations gives us a consistent sequence to use in computation. Without the order of operations, you could come up with different answers to the same computation problem. (Some of the early calculators, and some inexpensive ones, do NOT use the order of operations. In order to use these calculators, the user has to input the numbers in the correct order.)

// Save today's date.
var today = DateTime.Today;
// Calculate the age.
var age = today.Year - birthdate.Year;
// Go back to the year the person was born in case of a leap year
if (birthdate > today.AddYears(-age)) age--;

This is a strange way to do it, but if you format the date to yyyymmdd and subtract the date of birth from the current date then drop the last 4 digits you’ve got the age

I don’t know C#, but I believe this will work in any language.

20080814 – 19800703 = 280111
Drop the last 4 digits = 28.

C# Code:

int now = int.Parse(DateTime.Now.ToString("yyyyMMdd"));
int dob = int.Parse(dateOfBirth.ToString("yyyyMMdd"));
int age = (now - dob) / 10000;
</code>
Or alternatively without all the type conversion in the form of an extension method. Error checking omitted:
<code>
public static Int32 GetAge(this DateTime dateOfBirth)
{
    var today = DateTime.Today;

    var a = (today.Year * 100 + today.Month) * 100 + today.Day;
    var b = (dateOfBirth.Year * 100 + dateOfBirth.Month) * 100 + dateOfBirth.Day;

    return (a - b) / 10000;
}

I don’t know how the wrong solution can be accepted.
The correct C# snippet was written by Michael Stum

Here is a test snippet:

    DateTime bDay = new DateTime(2000, 2, 29);
    DateTime now = new DateTime(2009, 2, 28);
    MessageBox.Show(string.Format("Test {0} {1} {2}",
                    CalculateAgeWrong1(bDay, now),     // outputs 9
                    CalculateAgeWrong2(bDay, now),     // outputs 9
                    CalculateAgeCorrect(bDay, now)));  // outputs 8

Here you have the methods:

    public int CalculateAgeWrong1(DateTime birthDate, DateTime now)
    {
        return new DateTime(now.Subtract(birthDate).Ticks).Year - 1;
    }

    public int CalculateAgeWrong2(DateTime birthDate, DateTime now)
    {
        int age = now.Year - birthDate.Year;

        if (now < birthDate.AddYears(age))
            age--;

        return age;
    }

    public int CalculateAgeCorrect(DateTime birthDate, DateTime now)
    {
        int age = now.Year - birthDate.Year;

        if (now.Month < birthDate.Month || (now.Month == birthDate.Month && now.Day < birthDate.Day))
            age--;

        return age;
    }