Building a Project Starter with NPM Scripts

When it comes to building a simple front-end project, how do you get started? What are the tools you need? I suspect everyone will have a different answer. Do you start with a (JS or CSS) framework, or off-the-shelf boilerplate? Perhaps you use a task runner (like Gulp to orchestrate your project’s needs. Or do you start simple, with just HTML and a CSS file?

The front-end tooling landscape can be confusing, and at times overwhelming – and when you’re dedicating your time to learning HTML, CSS and Javascript, it feels like yet another thing you need to make time to learn. In this series of articles I want to help developers understand some of the tools and methodologies that have become commonplace for building web projects. Over the next three articles we’ll build a simple project starter (or boilerplate) together. We’ll cover:

  1. An introduction to using NPM scripts (this article) for compiling Sass, running a server and live reloading.
  2. Getting up and running with Parcel, a minimal-config application bundler.
  3. Building out a reusable Sass architecture

Feel free to skip over the parts you’re already familiar with.

Why do we need a project starter repository?

I’ve written previously on this blog about keeping things simple and building dependency-free — and for a basic, minimal site, this approach has a lot to recommend it. But the vast majority of my projects would benefit from a bit more tooling. In any given project, it’s likely that at the very least I’ll want to:

  • Run a local server
  • Compile SCSS to CSS, and minify the output
  • Live reload (show changes in the browser without the need for manual refresh)
  • Optimise images
  • Create SVG icon sprites

In larger projects, there are plenty more tooling options we could add into the mix to help us build performant, accessible websites. We might want module bundling, code splitting and transpiling. On the CSS side, perhaps we’d like to inline our critical CSS, or purge unused selectors.

If you don’t know what some of these words mean, you’re not alone! Front-end development has got a lot more complex in recent years, and it can be hard to keep abreast of the constant changes to best practices. One article that has really helped me understand the vast tooling landscape that these days falls into the realm of front-end development is Modern Javascript Explained For Dinosaurs. Although a couple of years old, this article is still extremely relevant, and explains succinctly how Javascript has evolved to become such a vital part of our workflow.

All this takes time to set up and configure, and to do it from scratch every time we start a new project wouldn’t be ideal. Which is why it’s useful to have a starter repository that we can clone or download, with everything we need to start coding straight away.

Choosing our tools

I’m not a person who loves spending time setting up complex tooling. I want my tools to demand as little time from me as possible, so that I can concentrate on the things I love doing! Whilst I’ve used Gulp in the past, it now seems a less necessary part of the toolchain: virtually all dependencies can be installed via NPM and configuring them with NPM scripts is no more difficult than configuring them with Gulp. So using a task runner seems a bit redundant, and would only add an extra dependency to the project.

The tools I’ve chosen here are a personal preference, and suit the kind of projects I like to build. They’re not necessarily everyone’s choice, and there are plenty of different ways to do things. But I hope this tutorial will help you get a bit more familiar with some of the tools that have become popular among developers, so that you can make your own choices.

With that in mind, let’s begin building our project starter, and learn about the tools we’ll be using along the way. Feel free to skip over any parts you’re already familiar with.

Installing Node.js

The very first thing we need to do to get our project set up to work with NPM scripts is to make sure we have Node.js installed globally. This sounds simple enough, but already things start to get a little more complicated when we realise there are a number of different ways to do this:

NVM is my preferred option, as it allows us to easily upgrade our node version, see which version we’re currently running, list other installed versions or switch to another version using single commands. But it requires additional steps to install depending on your setup, which is beyond the scope of this particular article.

Once you have Node installed (by whichever method suits you), you can check the currently installed version by running node -v. (You might want to upgrade to the latest version.) If you’re using NVM you could (optionally) create a .nvmrc config file to ensure you always run the correct Node version for your project.

NPM

Installing Node also installs NPM (Node Package Manager). This is basically a huge library of open source Javascript development tools (or packages) that anyone can publish to. We have direct access to this library of tools and (for better or worse!) can install any of them in our projects.

NPM or Yarn?

Yarn is an alternative package manager, similar to NPM, and almost as popular. In fact, many people consider it an improvement. It can be used in a similar way, to install dependencies. If you prefer to use Yarn over NPM, you can safely substitute NPM commands with the Yarn equivalent anywhere they’re used in this article.

Initialising the project

First, let’s create a new project folder, which we’ll (imaginitively) call new-project. Open the terminal, and inside that folder run:

npm init

Running this command brings up several steps for initialising our project in the command line, such as adding a name and description. You can hit Enter to skip through each of these if you don’t want to complete them right away – we’ll be able to edit them later on. You’ll then see that a package.json file has been created, which should look something like this:

{
	"name": "project-starter",
	"version": "1.0.0",
	"description": "",
	"main": "index.js",
	"scripts": {
		"test": "echo \"Error: no test specified\" && exit 1"
	},
	"author": "",
	"license": "ISC"
}

This file contains all the information about our project, and is where we can edit the details that we just skipped through.

Any packages that we install from NPM will be automatically listed in the package.json file. It’s also where we’ll configure the scripts that will build and run our project. We’ll install some packages and configure these shortly, but first we’ll need a basic project architecture, and some files to work with.

Project structure

We’ll start with a folder structure that looks like this:

new-project
	index.html
  src
    icons
    images
    js
    scss
  node_modules
  package.json

We’ve already generated the node_modules directory and package.json in the root of the project. We just need to create a directory called src, containing directories for images, JS, SCSS and icons, plus an index.html file.

Creating our folder structure from the command line

You could create the above folder structure manually, either in your text editor of choice or in your computer’s file system. But if you want to save time, you could do it from the terminal instead. In the root of the project, you could run:

touch index.html
mkdir src && cd src
mkdir js scss images icons
cd ../

Line by line, this code:

  1. Creates a new index.html file
  2. Creates a new src directory and moves us into the newly-created directory
  3. Creates directories inside src called jsscssimages and icons, and a file called index.html.
  4. Brings us back up to the project root.

Now let’s add the following to our index.html file so that we can see our site in the browser:

<!DOCTYPE html>
<html lang="en">
	<head>
		<meta charset="UTF-8" />
		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
		<meta http-equiv="X-UA-Compatible" content="ie=edge" />
		<title>Project starter</title>
		<link rel="stylesheet" type="text/css" href="dist/css/styles.css" />
	</head>
	<body>
		<h1>Hello world!</h1>
	</body>
</html>

Installing dependencies

Now that we have our basic folder structure, we can start to install some packages and write some NPM scripts that will let us build and view our website. The scripts we’re going to write will:

  1. Run a local server
  2. Compile Sass to CSS
  3. Watch for changes and reload the page whenever we update our HTML or CSS

Let’s install the node-sass package from NPM, which compiles .scss files to CSS. In the terminal run:

npm install node-sass --save-dev

Once this command has finished running, you should see a couple of new things:

  1. A directory called node_modules has been created
  2. In the package.json file, node-sass is now listed in “devDependencies”.
  3. Adds a package-lock.json file. This isn’t something we should ever need to touch.

Adding a .gitignore

The node_modules directory is where the code for all of our project dependencies will live. The contents of this folder should not be committed to Github (or your favourite repository host), as installing just a few dependencies could result in hundreds of thousands of files! So the next thing we should do is add a .gitignore file in the project root:

touch .gitignore && echo "node_modules" >> .gitignore

This command creates the .gitignore file and adds node_modules to it. (Again, you can do this manually if you prefer.) Now we are safe in the knowledge that our packages will not be committed.

If we’re not committing these files, then how can we share our dependencies with other users? Well, this down to the package.json file. It tells us the name and version number of any dependencies we have installed. Anyone who clones or forks the project (including us, when we use it to start a new project) can simply run npm install and all the associated dependencies will be fetched and downloaded from NPM.

Types of dependencies

When we installed node-sass we ran the install command with the --save-dev flag. This installs the project as a “dev dependency”. Other packages may not require this command, and save a package under “dependencies” instead. The difference is that regular dependencies are runtime dependencies, whereas dev dependencies are buildtime dependencies. node-sass is required to build your project, so it’s a dev dependency. But something like, say, a carousel plugin, or framework that needs to be downloaded on the client side, (like React) would need to be a regular dependency.

Now we’ll also install Browsersync as a dev dependency. Browsersync will run a local server and reload the browser when our files change.

npm install browser-sync --save-dev

Writing NPM scripts

Now it’s time to write some scripts to run our project. We’re going to write these in the “scripts” section of our package.json.

Sass to CSS

NPM scripts consist of a key (the name of the script, which is what we would type in the terminal in order to run it) and a value – the script itself, which will be executed when we run the command. First we’ll write the script which compiles Sass to CSS. We’ll give it the name scss (we could name it anything we like) and add it to our “scripts” section:

"scripts": {
  "scss": "node-sass --output-style compressed -o dist/css src/scss",
}

The node-sass package contains some options, some of which we’re defining here. We’re specifying the output style (“compressed”), the output directory (dist/css) and the source directory (src/scss), which is currently empty. Let’s create a source .scss file from the terminal:

touch src/scss/styles.scss

Add a few styles to the newly-created file, then go back to the terminal and run:

npm run scss

You should then see a new directory called dist has been created, containing your compiled CSS. Now, every time you make changes to your styles.scss file, you can run the script and those changes will be compiled.

Live reloading

Our first script is working great, but it’s not very useful yet, as every time we make changes to our code we need to got back to the terminal and run the script again. What we would be much better it to run a local server and see our changes reflected instantaneously in the browser. In order to do that we’ll write a script that uses Browsersync, which we’ve already installed.

First, let’s write the script that runs the server, which we’ll call serve:

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'"
}

In the --files option we’re listing the files that Browsersync should monitor. It will reload the page when any of these change. If we run this script now (npm run serve), it will start a local server and we can preview our web page by going to http://localhost:3000 in the browser.

Watching for changes

Currently we still need to run our scss script when we want to compile our Sass. What we need our scripts to do is:

  1. Watch our src/scss directory for changes.
  2. When a change occurs, compile this to CSS in dist/css.
  3. When dist/css is updated, reload the page.

First we need to install an NPM package called onchange, to watch for changes to the source files:

npm install onchange --save-dev

We can write NPM scripts that run other scripts. Let’s add the script that watches for changes and triggers our scss command to run:

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'",
	"watch:css": "onchange 'src/scss' -- npm run scss",
}

The watch:css script watches for changes using the onchange package (src/scss) and runs our scss script when changes occur.

Combining scripts

Now we need to run two commands in parallel: The serve command to run our server, and the watch:css command to compile our Sass to CSS, which will trigger the page reload. Using NPM scripts we can easily run commands consecutively using the && operator:

"scripts": {
  /*...*/
  "start": "npm run serve && npm run scss"
}

However, this won’t achieve what we want, as the script will wait until after the serve script has finished running before it begins running the scss script. If we go ahead and write this script, then run it in the terminal (npm start), then npm run scss won’t be triggered until we’ve stopped the server.

To enable us to run commands in parallel, we need to install another package. NPM has several options to choose from. The one I’ve picked is npm-run-all:

npm install npm-run-all --save-dev

The main options in this package (or at least, the ones we care about) are run-s and run-p. The former is for running sequentially, the latter is for running commands in parallel. Once we have installed this package, we can use it to write the script that runs both our serve and watch:css commands in parallel. (We’ll call it start.)

"scripts": {
	"scss": "node-sass --output-style compressed -o dist/css src/scss",
	"serve": "browser-sync start --server --files 'dist/css/*.css, **/*.html'",
	"watch:css": "onchange 'src/scss' -- npm run scss",
	"start": "run-p serve watch:css"
}

We now have a very basic starter project. We’ve written some scripts that allow us to simply type the command npm start to run a server, watch for changes, compile Sass to CSS and reload the page. An example repository can be found here.

We could now go ahead and install some packages and write scripts to automate some of our other tasks, such as optimising images, creating SVG sprites and uglifying JS. This CSS Tricks article has a great rundown of a few more scripts you might like to add, as well as a starter repository. (Be aware, one or two of the packages included in the example have since been deprecated. You may need to search NPM for substitutes.)

This may serve us perfectly well for small projects, but the more tasks we want to run, the more scripts we’ll need to write, and orchestrating them all becomes more complex. So, in the next article we’ll look at how Parcel, an application bundler, can automate a lot of these tasks for us with minimal configuration, and provide the tooling we need in order to build larger projects.

 

Dica: Quer testar já o novo explorador de ficheiros do Windows 10?

A Microsoft está constantemente a melhorar o Windows 10 e a criar novidades neste sistema operativo. Muitas vezes são apenas novas versões de ferramentas que já existem, mas que agora se adaptam a novas realidades.

Há muito que se fala que o Explorador do Windows pode receber uma nova roupagem e que ser até substituído. Uma nova versão já espera a sua vez dentro do Windows 10 e hoje vamos mostrar como a podem testar.

Este novo explorador de ficheiros do Windows 10 está ainda longe de estar pronto. Ainda assim, tem presentes as funções necessárias para ser usado no dia a dia. A navegação é simples e intuitiva, havendo ainda alguns pontos a serem tratados.

Saiba como chamar o novo Explorador de ficheiros

Para testar esta nova proposta da Microsoft, os utilizadores só precisam de abrir uma janela do explorador de ficheiros. Aí dentro, na barra de endereço, devem colocar o seguinte caminho: shell:AppsFolder\c5e2524a-ea46-4f67-841f-6a9465d9d515_cw5n1h2txyewy!App. Terminem este processo carregando em Enter.

Windows 10 explorador ficheiros Microsoft ferramentas

De imediato será aberta uma nova janela, com a versão UWP (Universal Windows Platform) do Explorador de ficheiros. Este será aberto na mesma localização onde a outra janela estava aberta.

Windows 10 tem novas ferramentas para os utilizadores

Podem navegar de forma normal, carregando nas pastas ou nos ficheiros presentes. Tudo será mantido da mesma forma que conhecem do Explorador de ficheiros do Windows 10. Contudo, a interface é toda mais simples e minimalista.

Windows 10 explorador ficheiros Microsoft ferramentas

Alguns elementos podem ser alterados, como a apresentação das pastas. Requer alguma habituação à localização das novidades, uma vez que não estão identificadas. Surgem pelos ícones, que mesmo assim são simples.

A Microsoft vai melhorar esta sua nova proposta

Se quiserem manter este explorador de ficheiros sempre acessível, tal é possível. Basta carregar com o botão direto do rato no ícone presente na barra de tarefas. Da lista de opções presentes, devem escolher a opção Afixara na barra de tarefas.

Windows 10 explorador ficheiros Microsoft ferramentas

O ícone deste novo explorador vai estar presente de imediato e bastará ao utilizador clicar nele para que seja aberta a janela que esperam e procuram usar. A sua remoção só necessita do processo inverso para ser feita.

Este não é ainda um explorador terminado e lançado a ser usado. Está já maduro e principalmente pronto a ser usado em testes no dia a dia. Experimentem o que a Microsoft está criar e o caminho que vai seguir no futuro do seu sistema operativo.

Os melhores editores de vídeo gratuitos para usar online

Com os smartphones a serem cada vez mais máquinas de fotografar e filmar e com cada vez mais criadores de conteúdo para a Internet é importante conhecer diferentes propostas de ferramentas de edição disponíveis.

Para quem pretende editar vídeo em qualquer lugar, de forma rápida e gratuita, estas são algumas das melhores propostas de editores de vídeo para usar online.

Os melhores editores de vídeo gratuitos para usar online

ClipChamp

Em primeiro lugar, sugerimos o ClipChamp, uma das mais completas soluções para edição de vídeo online. Além das ferramentas de edição de vídeo, também oferece um compressor de vídeo, conversor e gravador de webcam.

A plataforma de trabalho é bastante intuitiva e dando a qualquer pessoa a possibilidade de editar com facilidade. O resultado final pode ser gravado diretamente no computador ou partilhado em qualquer serviço de nuvem, como o Google Drive, por exemplo.


Online Video Cutter

O Online Video Cutter não é propriamente um editor de vídeo, mas poderá ser uma solução útil neste universo. Basicamente é um serviço web prático para quando o utilizador necessita de cortar um pequeno ficheiro de vídeo. Além disso, suporta praticamente todos formatos de vídeo disponível. Até ao momento o serviço está limitado a ficheiros com 500 MB.


WeVideo

Além do corte e da divisão de vídeo básicos, o WeVideo permite adicionar marcadores a clips específicos ou texto simples estático e textos explicativos ao vídeo. Permite ainda adicionar transições, gráficos de plano de fundo, sobreposições e quadros.

O WeVideo encontra-se disponível online, mas pode também ser encontrado nas lojas de aplicações móveis da Apple e da Google, para iOS e Android, respetivamente.


Kizoa

O Kizoa destaca-se entre estes serviços online pelo seu amplo conjunto de efeitos e transições. Os vídeos podem ser criados a partir de diversos formatos, podendo ser adicionadas músicas, textos e efeitos especiais.

Além de poderem ser utilizados ficheiros a partir do PC, o serviço também consegue suportar as imagens disponíveis nas suas contas de redes sociais.


Windows Server 2008 – Vamos criar um domínio

Apesar de hoje em dia os sistemas operativos móveis serem o centro das atenções, há sistemas que são fundamentais nas empresas e que fazem parte estrutura da Internet.

Hoje vamos dar início a uma rubrica que terá como objectivo ensinar a instalar e a configurar um conjunto de serviços no Windows Server 2008. Hoje vamos ensinar a criar um domínio interno.

Como referido, pretende-se com estes tutoriais ensinar a explorar o Windows Server 2008 e a instalar/configurar serviços como Active Directoy, DNS, DHCP, etc. Para começar vamos ensinar a criar um domínio Interno. A elaboração deste tutoriais têm como base o Virtualbox para virtualizar o Windows Server 2008 e também algumas outras máquinas com Windows .

Para a criação de um domínio interno é necessário instalar o serviço de directório Active Directory.

Active Directory é uma implementação de um serviço de directório no protocolo LDAP, que mantêm as informações sobre os objectos que fazem parte de uma rede de dados. São considerados objectos os utilizadores virtuais, os grupos, os computadores, as unidades organizacionais, etc. (Depois de instalado o Active Directory iremos explorar melhor esse serviço).

Como instalar o Active Directory?

Para instalar o serviço Active Directory (AD) devem seguir os seguintes passos.

1) Nas Initial Configurations Tasks, carregamos em Customize This Server > Add Roles

Nota: Para aceder a esta interface, use o comando oobe.exe

ad_00

 

2) Next…

ad_01

3) Seleccionar o serviço “Active Directory Domain Services

ad_02

4) Next…

ad_03

5) Carregar em Install

ad_04

…o processo de instalação do AD demora cerca de 2 a 3 minutos

ad_05Serviço AD instalado!

ad_06

6) A configuração do AD é feita recorrendo ao comando dcpromo.exe  como referido várias vezes durante do processo de instalação do AD. Depois de executado o dcpromo, na primeira interface carregamos em Next,

ad_07

7) Next…

ad_08

8) Escolher a opção Create a new domain in a forest

ad_09

9) …e e seguida indicamos o nome do dominio que pretendemos criar. Para este exemplo vamos criar o dominio pplware.com

ad_10

10) Nível funcional ao nível da floresta escolhemos Windows Server 2008

ad_11

11) Nível funcional ao nível do Domínio Windows Server 2008

ad_12

12) Para que o AD funcione correctamente é recomendado que seja instalado o serviço de DNS no primeiro controlador de domínio (Máquina onde vamos instalar o AD)

ad_13

13) Não esquecer que o servidor deve ter um IP estático configurado. Se ainda não o fez, pode aproveitar este passo para efectuar essa configuração.

ad_14

13) Carregamos agora em YES (Depois em outros tutoriais tratamos do serviço de DNS)

ad_15

14) Indicamos os directórios onde vão ficar os ficheiros de log das bases de dados, controlador de dominio, etc.

ad_16

…Apresentação de um sumário das configurações realizadas

ad_17

…Esperamos mais alguns minutos para que toda a estrutura do AD seja configurada

ad_18

E após uns 5 minutos temos o AD instalado. Num próximo artigo iremos explorar as funcionalidades de um AD. De referir que o Windows 2008 corre bem numa máquina virtual com apenas 512 MB de RAM (no mínimo). Hoje ficamos por aqui e esperamos o feedback do vosso lado.

Zenkit reinventa o Kanban board e apresenta uma solução mais abrangente

O quadro Kanban, ou Kanban board, é imprescindível no dia a dia de imensas pessoas e empresas. De forma resumida, trata-se de um quadro que agrupa as tarefas em vários estados, como To-DoDoing e Done. Essa simples organização basta para que os projetos possam ter um progresso mais otimizado e controlado.

Mas… como poderá isto ser reinventado? O Zenkit chegou à solução e apresenta, no seu serviço web, um Kanban board com sub-tarefas, visualização por hierarquia e outros filtros poderosos.

A tecnologia é um aliado na organização e otimização do nosso trabalho, não há dúvidas disso. Nesse sentido, há imensas soluções que procuram facilitar a vida dos utilizadores, umas melhores que outras, e os Kanban boards são adequados para utilizar em qualquer tipo de trabalho.

A ideia inicial surgiu na década de 1960, quando a Toyota criou então o sistema Kanban que não era mais que um sistema de abastecimento e controlo de stock. Ainda hoje o sistema é utilizado frequentemente por diversas empresas. No fundo, baseava-se na movimentação e fornecimento de produtos de acordo com o seu consumo, fazendo com que não haja reabastecimento de materiais de terem sido solicitados num estágio anterior. Nessa lógica, é então possível criar uma adaptação para qualquer tipo de tarefas que se relacionem de alguma forma.

O Kanban board reinventado pelo Zenkit

Os Kanban boards podem ser uma dor de cabeça para projetos muito complexos. Assim, o Zenkit desenvolveu uma funcionalidade de sub-tarefa de forma a permitir uma estrutura hierarquizada. Ou seja, os Kanban boards enormes passam agora a ter uma forma mais agradável e funcional.

De acordo com um estudo da KPMG, cerca de 70% das empresas sofreu pelo menos uma falha de projeto nos últimos 12 meses. Desses, 50% falharam em não conseguir concretizar aquilo a que se propuseram. E é aí que esta nova funcionalidade pode então fazer a diferença.

Uma hierarquia estruturada pode ajudar na separação de tarefas num quadro Kanban. Além disso, permite determinar de forma intuitiva onde pertence cada tarefa. Assim, há uma visão geral mais clara e focada no fluxo de trabalho.

Sempre fomos grandes fãs dos Kanban boards, mas reparámos que a sua falta de estrutura poderia causar sobrelotação e confusão. Por acidente, enquanto trabalhávamos nas novas funcionalidades de sub-tarefas, encontrámos a solução para este problema: filtros hierárquicos. São uma forma intuitiva de encontrar rapidamente tarefas relacionadas ou ter uma visão geral das tarefas chave. Estamos confiantes que estas novas funcionalidades irão mudar para sempre a forma de como utiliza um quadro Kanban.

Referiu Martin Welker, CEO do Zenkit.

As novas funcionalidades

Nestas novas funcionalidades, podemos contar com:

  • Filtro hierárquico – permite ver apenas as tarefas de nível superior, não sendo então necessário fazer uma lista separada para ver o cenário geral.
  • Filtro de sub-tarefas – permite ver todos os sub-itens de um item específico, apenas com um clique. As tarefas não relacionadas, de outros itens, desaparecem do quadro. Dessa forma, é possível ter uma visão geral de um sub-projeto como se fosse um único Kanban board. Isso poderá evidenciar os problemas no desenvolvimento dos projetos.
  • Novo mapa mental – é uma mapa que se liga diretamente à vista de hierarquia, oferecendo uma forma mais expressiva de trabalhar com os mesmos dados.
  • Fórmulas recursivas – permitem agregar o valor das sub-tarefas.
  • Relacionamento na conclusão de tarefas – capacidade de marcar automaticamente todas as sub-tarefas como concluídas após marcar a tarefa principal como concluída.

Além destas novas funcionalidades, o Zenkit está agora pronto a ser utilizado por empresas, com a introdução da funcionalidade Organizações. Ou seja, permite que grandes empresas façam a gestão dos seus utilizadores, com suporte para SSO baseado em SAML e provisionamento via SCIM.

O Zenkit é um serviço Web com aplicações para Windows, macOS, Linux e também para plataformas móveis Android e iOS.

Zenkit