Design & UX
Kelsey Bryant, Feb 07

Artsigma Opens up about His Full-Time Career on 99designs

Curious about pursuing a career in design? artsigma from 99designs opens up about his career to date and how he got to where he is now.
Louis Lazaris, Feb 07

More HTML5 Semantics: New Elements and Features

In this section, let's touch on lesser-known elements, attributes, and features that have been added to the HTML5 spec
Pierre-Yves Saumont, Feb 06

In Praise of Laziness

Java is known as a strict language regarding references and method arguments. It's however possible (and very useful) to implement laziness in types.
James Hibbard, Feb 06

SitePoint 2017 JavaScript Survey — the Results Are In

The results of our 2017 JavaScript survey are in! James Hibbard takes a look at how you answered and addresses some of the comments raised.
Bruno Skvorc, Feb 06

Quick Tip: LetsEncrypt "server" error fix on Ubuntu 16.04

Running into the cryptic "server" error when renewing your server's HTTPS certificates with LetsEncrypt? Here's how to solve it.
M. David Green, Feb 06

Scrum Artifacts: Product Backlog

Stories for the development team emerge from the product owner's product backlog.
Abhishek Talreja, Feb 03

How Processes Overcome These Small Business Productivity Hurdles

Businesses without good process management leave a lot of money on the table. Here's how you can boost your small business productivity.
Tiffany Brown, Feb 03

CSS Pseudo-classes: :not() and :target

Perhaps the most powerful of this new crop of pseudo-classes is :not(). It returns all elements except for those that match the selector argument.
Nicolai Parlog, Feb 02

Java Module System Hands-On Guide

In this post we'll take an existing demo application and modularize it with Java 9. If you want to follow along, head over to GitHub, where all of the code can be found. The setup instructions are important to get the scripts running with Java 9. For brevity, I removed the prefix org.codefx.demo from all package, module, and folder names in this article.

The Application Before Jigsaw

Even though I do my best to ignore the whole Christmas kerfuffle, it seemed prudent to have the demo uphold the spirit of the season. So it models an advent calendar:
  • There is a calendar, which has 24 calendar sheets.
  • Each sheet knows its day of the month and contains a surprise.
  • The death march towards Christmas is symbolized by printing the sheets (and thus the surprises) to the console.
Of course the calendar needs to be created first. It can do that by itself but it needs a way to create surprises. To this end it gets handed a list of surprise factories. This is what the main method looks like:
public static void main(String[] args) {
	List<SurpriseFactory> surpriseFactories = Arrays.asList(
			new ChocolateFactory(),
			new QuoteFactory()
	Calendar calendar =
The initial state of the project is by no means the best of what is possible before Jigsaw. Quite the contrary, it is a simplistic starting point. It consists of a single module (in the abstract sense, not the Jigsaw interpretation) that contains all required types:
  • "Surprise API" - Surprise and SurpriseFactory (both are interfaces)
  • "Calendar API" - Calendar and CalendarSheet to create the calendar
  • Surprises - a couple of Surprise and SurpriseFactory implementations
  • Main - to wire up and run the whole thing.
Compiling and running is straight forward (commands for Java 8):
# compile
javac -d classes/advent ${source files}
# package
jar -cfm jars/advent.jar ${manifest and compiled class files}
# run
java -jar jars/advent.jar

Entering Jigsaw Land

The next step is small but important. It changes nothing about the code or its organization but moves it into a Jigsaw module.


So what's a module? To quote the highly recommended State of the Module System:
A module is a named, self-describing collection of code and data. Its code is organized as a set of packages containing types, i.e., Java classes and interfaces; its data includes resources and other kinds of static information. To control how its code refers to types in other modules, a module declares which other modules it requires in order to be compiled and run. To control how code in other modules refers to types in its packages, a module declares which of those packages it exports.
(The last paragraph is actually from an old version of the document but I like how it summarizes dependencies and exports.) So compared to a JAR a module has a name that is recognized by the JVM, declares which other modules it depends on and defines which packages are part of its public API.


A module's name can be arbitrary. But to ensure uniqueness it is recommended to stick with the inverse-URL naming schema of packages. So while this is not necessary it will often mean that the module name is a prefix of the packages it contains.


A module lists the other modules it depends on to compile and run. This is true for application and library modules but also for modules in the JDK itself, which was split up into about 100 of them (have a look at them with java --list-modules). Again from the design overview:
When one module depends directly upon another in the module graph then code in the first module will be able to refer to types in the second module. We therefore say that the first module reads the second or, equivalently, that the second module is readable by the first. [...] The module system ensures that every dependence is fulfilled by precisely one other module, that the module graph is acyclic, that every module reads at most one module defining a given package, and that modules defining identically-named packages do not interfere with each other.
When any of the properties is violated, the module system refuses to compile or launch the code. This is an immense improvement over the brittle classpath, where e.g. missing JARs would only be discovered at runtime, crashing the application. It is also worth to point out that a module is only able to access another's types if it directly depends on it. So if A depends on B, which depends on C, then A is unable to access C unless it requires it explicitly.


A module lists the packages it exports. Only public types in these packages are accessible from outside the module. This means that public is no longer really public. A public type in a non-exported package is as inaccessible to the outside world as a non-public type in an exported package. Which is even more inaccessible than package-private types are before Java 9 because the module system does not even allow reflective access to them. As Jigsaw is currently implemented command line flags are the only way around this.


To be able to create a module, the project needs a in its root source directory:
module advent {
    // no imports or exports
Wait, didn't I say that we have to declare dependencies on JDK modules as well? So why didn't we mention anything here? All Java code requires Object and that class, as well as the few others the demo uses, are part of the module java.base. So literally every Java module depends on java.base, which led the Jigsaw team to the decision to automatically require it. So we do not have to mention it explicitly. The biggest change is the script to compile and run (commands for Java 9):
# compile (include
javac -d classes/advent ${source files}
# package (add module-info.class and specify main class)
jar --create \
	--file=mods/advent.jar \
	--main-class=advent.Main \
	${compiled class files}
# run (specify a module path and simply name to module to run)
java --module-path mods --module advent
We can see that compilation is almost the same - we only need to include the new in the list of classes. The jar command will create a so-called modular JAR, i.e. a JAR that contains a module. Unlike before we need no manifest anymore but can specify the main class directly. Note how the JAR is created in the directory mods. Utterly different is the way the application is started. The idea is to tell Java where to find the application modules (with --module-path mods, this is called the module path) and which module we would like to launch (with --module advent). jigsaw-demo-hands-on

Splitting Into Modules

Now it's time to really get to know Jigsaw and split that monolith up into separate modules.
Aleczander Gamboa, Feb 02

Meet the Top 3% Disrupting the Freelance Industry

Introducing Toptal - an elite talent agency that houses the top 3% of best software developers, UX/UI designers and finance experts the world has to offer.
Christopher Pitt, Feb 02

How to Make Modern PHP More Modern? With Preprocessing!

Chris adds some unexpected functionality to PHP, and all without custom extensions or recompiling. Let's unlock the power of macros and preprocessors!
Craig Buckler, Feb 02

Take the Pain Out of Form-Building with JotForm 4.0

Craig Buckler looks at JotForm 4.0, a tool that enables people without a technical background to build advanced, beautiful forms.
Design & UX
Kelsey Bryant, Feb 02

How Meella Accidentally Became a Full-Time Book Cover Designer

How do you break into the book cover design industry? Book designer Miladinka Milic shares her insights and how she stumbled into the industry by accident.
M. David Green, Feb 02

Scrum Artifacts: Stories

One of the most basic artifacts of scrum for web and mobile work is the story that describes a feature to be worked on.
George Martsoukos, Feb 01

Animated Filtering & Sorting with the MixItUp 3 JS Library

George Martsoukos introduces MixItUp 3, a high-performance JavaScript library that allows you to animate filtering and sorting of page content.
Aleczander Gamboa, Feb 01

Turn Your Side Project into a Full-Time Gig: Tips from Hacking UI

Hacking UI and Side Project Accelerator Co-Founder David Tinter shares his top tips to turning your side project into a full-time gig.
Nicolai Parlog, Feb 01

Java's Switch Statement in Three Minutes

Java's switch statement allows easy selection of execution paths based on a variable's value. Switches can replace if-else-if chains.
Valdio Veliu, Feb 01

Mastering Complex Lists with the Android RecyclerView

Valdio Veliu looks at the RecyclerView in Android, perfect for handling long lists of data efficiently.
Design & UX
John Stevens, Feb 01

6 Email Hacks Guaranteed to Boost Results from Your Email Efforts

According to the Direct Marketing Association, you can expect an ROI of $38 for every $1 you spend on email marketing. Small tweaks can be big money.
Louis Lazaris, Feb 01

More HTML5 Semantics: Changes to Existing Features

While new elements and APIs have been the primary focus of HTML5, this latest iteration of web markup has also brought with it changes to existing elements.
Design & UX
Kelsey Bryant, Jan 31

Kerry Ellis Shares Her Passion for Book Cover Design

What makes a good book cover designer, and how can you work with one? Kerry Ellis, one of 99designs' top designers, shares her advice.
Shaumik Daityari, Jan 31

How to Import Data and Export Results in R

Shaumik explains how to extract data from text files, CSV files and databases, and how to send that data to a web server.
Tania Rascia, Jan 31

A Beginner's Guide to JavaScript Variables and Datatypes

Get a solid understanding of the language from first principles, as Tania Rascia explains the basics of JavaScript variables and datatypes.
Louis Lazaris, Jan 31

20+ Docs and Guides for Front-end Developers (No. 11)

Louis Lazaris is here with installment number 11 of his series on fantastic learning resources, docs and guides for front-end developers