Introducing the SitePoint Blockchain Newsletter

Original Source: https://www.sitepoint.com/introducing-the-sitepoint-blockchain-newsletter/

Whether it’s being hailed as a game-changer or derided as hype, these days blockchain is everywhere. But it’s hard to get trustworthy, unbiased news and tutorials about the tech. If you’re trying to enter the blockchain dev world, there’s a high price of entry.

This newsletter will offer a curated collection of links – news, tutorials, tool and projects – that’ll highlight some of the more interesting and exciting developments in this emerging field. These will be sourced by me, Adam. You may know me from my weekly Back-end and Design newsletters, or from Versioning, my daily newsletter focused on the bleeding-edge of web dev and design.

I promise this will be both on-the-chain and off-the-chain! Sign up here!

Name

Email

Subscribe

Still unsure? Here’s the first edition!

Bright Spark
Resources

First up, links to two programming languages for writing smart contracts on Ethereum.

Flint and

Solidity

For the latter, here’s a collection of programming patterns and best-practices

A new idea: crypto composables, allowing one non-fungible token to own another. The (useful, for me) metaphor used in the article was buying a house – you’re actually buying the title for land, the house is just part of the transaction.

Advice for those using React Create App to build DApps – the React Service Worker may trip you up.

DAppy Gilmore
Learning

An intro to a 2-month study plan for learning blockchain, and the links for the various subjects mentioned.

An intro exactly what DApps are.

5 very interesting DApps.

If you haven’t already, check out the Golem network, given it’s a very prominent example of a non-cryptocurrency application of the blockchain, here’s an intro to what that thing is.

An intro to EOS, the Epic Operating System, set to launch June 7.

A good podcast discussion of Popula, a blockchain-powered, censorship-proof(? maybe) publication.

Cryptocurrency vloggers are literally being robbed because they’re sharing waaaaay too much information about their logins, portfolios etc.

Whole Latte Love
Fun stuff

This Seattle startup is combining coffee and the blockchain and virtual reality to transform the coffee industry. Is it possible, and just go with me here, that they are maybe throwing too many things into the mix here? Just me? OK.

Finally, CryptoWorldCup is a DApp on the Ethereum blockchain that allows you to securely, transparently bet on the Russia World Cup. If you’re curious, this thread on /r/ethdev has a nice little critique of the structure of the DApp – might be handy to all y’all Dapp-ists out there.

There’s the inaugural Blockchain Newsletter! I hope it was to your liking – please, please, please let me know if you have ideas or requests for improvements. On my end, it’s fun to explore this world that I usually just glimpse and slowly back away from.

Name

Email

Subscribe

Continue reading %Introducing the SitePoint Blockchain Newsletter%

Working Together: How Designers And Developers Can Communicate To Create Better Projects

Original Source: https://www.smashingmagazine.com/2018/04/working-together-designers-developers/

Working Together: How Designers And Developers Can Communicate To Create Better Projects

Working Together: How Designers And Developers Can Communicate To Create Better Projects

Rachel Andrew

2018-04-24T16:50:19+02:00
2018-04-24T15:30:31+00:00

Among the most popular suggestions on Smashing Magazine’s Content User Suggestions board is the need of learning more about the interaction and communication between designers and developers. There are probably several articles worth of very specific things that could be covered here, but I thought I would kick things off with a general post rounding up some experiences on the subject.

Given the wide range of skills held by the line-up at our upcoming SmashingConf Toronto — a fully live, no-slides-allowed event, I decided to solicit some feedback. I’ve wrapped those up with my own experience of 20 years working alongside designers and other developers. I hope you will add your own experiences in the comments.

Some tips work best when you can be in the same room as your team, and others are helpful for the remote worker or freelancer. What shines through all of the advice, however, is the need to respect each other, and the fact that everyone is working to try and create the best outcome for the project.

Working Remotely And Staying Connected

The nomadic lifestyle is not right for everyone, but the only way to know for sure is to try. If you can afford to take the risk, go for it. Javier Cuello shares his experience and insights from his four years of travel and work. Read article →

For many years, my own web development company operated as an outsourced web development provider for design agencies. This involved doing everything from front-end development to implementing e-commerce and custom content management solutions. Our direct client was the designer or design agency who had brought us on board to help with the development aspect of the work, however, in an ideal situation, we would be part of the team working to deliver a great end result to the end client.

Sometimes this relationship worked well. We would feel a valued part of the team, our ideas and experience would count, we would work with the designers to come up with the best solution within budgetary, time, and other constraints.

In many cases, however, no attempt was made to form a team. The design agency would throw a picture of a website as a PDF file over the fence to us, then move on to work on their next project. There was little room for collaboration, and often the designer who had created the files was busy on some other work when we came back with questions.

Getting workflow just right ain’t an easy task. So are proper estimates. Or alignment among different departments. That’s why we’ve set up ‘this-is-how-I-work’-sessions — with smart cookies sharing what works well for them. A part of the Smashing Membership, of course.

Explore features →

Smashing TV, with live sessions for professional designers and developers.

It was an unsatisfactory way to work for everyone. We would be frustrated because we did not have a chance to help ensure that what was designed was possible to be built in a performant and accessible way, within the time and budget agreed on. The designer of the project would be frustrated: Why were these developers asking so many questions? Can they not just build the website as I have designed? Why are the fonts not the size I wanted?

The Waterfall versus Agile argument might be raised here. The situation where a PDF is thrown over the fence is often cited as an example of how bad a Waterfall approach is. Still, working in a fully Agile way is often not possible for teams made of freelancers or separate parties doing different parts of the work. Therefore, in reading these suggestions, look at them through the lens of the projects you work on. However, try not to completely discount something as unworkable because you can’t use the full process. There are often things we can take without needing to fully adopt one methodology or another.

Setting Up A Project For Success

I came to realize that very often the success of failure of the collaboration started before we even won the project, with the way in which we proposed the working relationship. We had to explain upfront that experience had taught us that the approach of us being handed a PDF, quoting and returning a website did not give the best results.

Projects that were successful had a far more iterative approach. It might not be possible to have us work alongside the designers or in a more Agile way. However, having a number of rounds of design and development with time for feedback from each side went a long way to prevent the frustrations of a method where work was completed by each side independently.

Creating Working Relationships

Having longer-term relationships with an agency, spanning a number of projects worked well. We got to know the designers, learned how they worked, could anticipate their questions and ensure that we answered them upfront. We were able to share development knowledge, the things that made a design easier or harder to implement which would, therefore, have an impact on time and budget. They were able to communicate better with us in order to explain why a certain design element was vital, even if it was going to add complexity.

For many freelance designers and developers, and also for those people who work for a distributed company, communication can become mostly text-based. This can make it particularly hard to build relationships. There might be a lot of communication — by email, in Slack, or through messages on a project management platform such as Basecamp. However, all of these methods leave us without the visual cues we might pick up from in-person meetings. An email we see as to the point may come across to the reader as if we are angry. The quick-fire nature of tools such as Slack might leave us committing in writing something which we would not say to that person while looking into their eyes!

Freelance data scientist Nadieh Bremer will talk to us about visualizing data in Toronto. She has learned that meeting people face to face — or at least having a video call — is important. She told me:

Nadieh Bremer

“As a remote freelancer, I know that to interact well with my clients I really need to have a video call (stress on the video) I need to see their face and facial/body interactions and they need to see mine. For clients that I have within public transport distance, I used to travel there for a first ‘getting to know each other/see if we can do a project’ meeting, which would take loads of time. But I noticed for my clients abroad (that I can’t visit anyway) that a first client call (again, make sure it’s a video-call) works more than good enough.

It’s the perfect way to weed out the clients that need other skills that I can give, those that are looking for a cheap deal, and those where I just felt something wasn’t quite clicking or I’m not enthusiastic about the project after they’ve given me a better explanation. So these days I also ask my clients in the Netherlands, where I live, that might want to do a first meeting to have it online (and once we get on to an actual contract I can come by if it’s beneficial).”

Working In The Open

Working in the open (with the project frequently deployed to a staging server that everyone had access to see), helped to support an iterative approach to development. I found that it was important to support that live version with explanations and notes of what to look at and test and what was still half finished. If I just invited people to look at it without that information we would get lists of fixes to make to unfinished features, which is a waste of time for the person doing the reporting. However, a live staging version, plus notes in a collaboration tool such as Basecamp meant that we could deploy sections and post asking for feedback on specific things. This helped to keep everyone up to date and part of the project even if — as was often the case for designers in an agency — they had a number of other projects to work on.

There are collaboration tools to help designers to share their work too. Asking for recommendations on Twitter gave me suggestions for Zeplin, Invision, Figma, and Adobe XD. Showing work in progress to a developer can help them to catch things that might be tricky before they are signed off by the client. By sharing the goal behind a particular design feature within the team, a way forward can be devised that meets the goal without blowing the budget.

Screenshot of the Zeplin homepage

Zeplin is a collaboration tool for developers and designers

Scope Creep And Change Requests

The thing about working in the open is that people then start to have ideas (which should be a positive thing), however, most timescales and budgets are not infinite! This means you need to learn to deal with scope creep and change requests in a way that maintains a good working relationship.

We would often get requests for things that were trivial to implement with a message saying how sorry they were about this huge change and requests for incredibly time-consuming things with an assumption it would be quick. Someone who is not a specialist has no idea how long anything will take. Why should they? It is important to remember this rather than getting frustrated about the big changes that are being asked for. Have a conversation about the change, explain why it is more complex than it might appear, and try to work out whether this is a vital addition or change, or just a nice idea that someone has had.

If the change is not essential, then it may be enough to log it somewhere as a phase two request, demonstrating that it has been heard and won’t be forgotten. If the big change is still being requested, we would outline the time it would take and give options. This might mean dropping some other feature if a project has a fixed budget and tight deadline. If there was flexibility then we could outline the implications on both costs and end date.

With regard to costs and timescales, we learned early on to pad our project quotes in order that we could absorb some small changes without needing to increase costs or delay completion. This helped with the relationship between the agency and ourselves as they didn’t feel as if they were being constantly nickel and dimed. Small changes were expected as part of the process of development. I also never wrote these up in a quote as contingency, as a client would read that and think they should be able to get the project done without dipping into the contingency. I just added the time to the quote for the overall project. If the project ran smoothly and we didn’t need that time and money, then the client got a smaller bill. No one is ever unhappy about being invoiced for less than they expected!

This approach can work even for people working in-house. Adding some time to your estimates means that you can absorb small changes without needing to extend the timescales. It helps working relationships if you are someone who is able to say yes as often as possible.

This does require that you become adept at estimating timescales. This is a skill you can develop by logging your time to achieve your work, even if you don’t need to log your time for work purposes. While many of the things you design or develop will be unique, and seem impossible to estimate, by consistently logging your time you will generally find that your ballpark estimates become more accurate as you make yourself aware of how long things really take.

Respect

Aaron Draplin will be bringing tales from his career in design to Toronto, and responded with the thought that it comes down to respect for your colleague’s craft:

Aaron Draplin

“It all comes down to respect for your colleague’s craft, and sort of knowing your place and precisely where you fit into the project. When working with a developer, I surrender to them in a creative way, and then, defuse whatever power play they might try to make on me by leading the charges with constructive design advice, lightning-fast email replies and generally keeping the spirit upbeat. It’s an odd offense to play. I’m not down with the adversarial stuff. I’m quick to remind them we are all in the same boat, and, who’s paying their paycheck. And that’s not me. It’s the client. I’ll forever be on their team, you know? We make the stuff for the client. Not just me. Not ‘my team’. We do it together. This simple methodology has always gone a long way for me.”

I love this, it underpins everything that this article discusses. Think back to any working relationship that has gone bad, how many of those involved you feeling as if the other person just didn’t understand your point of view or the things you believe are important? Most reasonable people understand that compromise has to be made, it is when it appears that your point of view is not considered that frustration sets in.

There are sometimes situations where a decision is being made, and your experience tells you it is going to result in a bad outcome for the project, yet you are overruled. On a few occasions, decisions were made that I believed so poor; I asked for the decision and our objection to it be put in writing, in order that we could not be held accountable for any bad outcome in future. This is not something you should feel the need to do often, however, it is quite powerful and sometimes results in the decision being reversed. An example would be of a client who keeps insisting on doing something that would cause an accessibility problem for a section of their potential audience. If explaining the issue does not help, and the client insists on continuing, ask for that decision in writing in order to document your professional advice.

Learning The Language

I recently had the chance to bring my CSS Layout Workshop not to my usual groups of front-end developers but instead to a group of UX designers. Many of the attendees were there not to improve their front-end development skills, but more to understand enough of how modern CSS Layout worked that they could have better conversations with the developers who built their designs. Many of them had also spent years being told that certain things were not possible on the web, but were realizing that the possibilities in CSS were changing through things like CSS Grid. They were learning some CSS not necessarily to become proficient in shipping it to production, but so they could share a common language with developers.

There are often debates on whether “designers should learn to code.” In reality, I think we all need to learn something of the language, skills, and priorities of the other people on our teams. As Aaron reminded us, we are all on the same team, we are making stuff together. Designers should learn something about code just as developers should also learn something of design. This gives us more of a shared language and understanding.

Seb Lee-Delisle, who will speak on the subject of Hack to the Future in Toronto, agrees:

Seb Lee-Delisle

“I have basically made a career out of being both technical and creative so I strongly feel that the more crossover the better. Obviously what I do now is wonderfully free of the constraints of client work but even so, I do think that if you can blur those edges, it’s gonna be good for you. It’s why I speak at design conferences and encourage designers to play with creative coding, and I speak at tech conferences to persuade coders to improve their visual acuity. Also with creative coding. 🙂 It’s good because not only do I get to work across both disciplines, but also I get to annoy both designers and coders in equal measure.”

I have found that introducing designers to browser DevTools (in particular the layout tools in Firefox and also to various code generators on the web) has been helpful. By being able to test ideas out without writing code, helps a designer who isn’t confident in writing code to have better conversations with their developer colleagues. Playing with tools such as gradient generators, clip-path or animation tools can also help designers see what is possible on the web today.

Screenshot of Animista

Animista has demos of different styles of animation

We are also seeing a number of tools that can help people create websites in a more visual way. Developers can sometimes turn their noses up about the code output of such tools, and it’s true they probably won’t be the best choice for the production code of a large project. However, they can be an excellent way for everyone to prototype ideas, without needing to write code. Those prototypes can then be turned into robust, permanent and scalable versions for production.

An important tip for developers is to refrain from commenting on the code quality of prototypes from members of the team who do not ship production code! Stick to what the prototype is showing as opposed to how it has been built.

A Practical Suggestion To Make Things Visual

Eva-Lotta Lamm will be speaking in Toronto about Sketching and perhaps unsurprisingly passed on practical tips for helping conversation by visualizing the problem to support a conversation.

Eva-Lotta Lamm

Creating a shared picture of a problem or a solution is a simple but powerful tool to create understanding and make sure they everybody is talking about the same thing.

Visualizing a problem can reach from quick sketches on a whiteboard to more complex diagrams, like customer journey diagrams or service blueprints.

But even just spatially distributing words on a surface adds a valuable layer of meaning. Something as simple as arranging post-its on a whiteboard in different ways can help us to see relationships, notice patterns, find gaps and spot outliers or anomalies. If we add simple structural elements (like arrows, connectors, frames, and dividers) and some sketches into the mix, the relationships become even more obvious.

Visualising a problem creates context and builds a structural frame that future information, questions, and ideas can be added to in a ‘systematic’ way.

Visuals are great to support a conversation, especially when the conversation is ‘messy’ and several people involved.

When we visualize a conversation, we create an external memory of the content, that is visible to everybody and that can easily be referred back to. We don’t have to hold everything in our mind. This frees up space in everybody’s mind to think and talk about other things without the fear of forgetting something important. Visuals also give us something concrete to hold on to and to follow along while listening to complex or abstract information.

When we have a visual map, we can point to particular pieces of content — a simple but powerful way to make sure everybody is talking about the same thing. And when referring back to something discussed earlier, the map automatically reminds us of the context and the connections to surrounding topics.

When we sketch out a problem, a solution or an idea the way we see it (literally) changes. Every time we express a thought in a different medium, we are forced to shape it in a specific way, which allows us to observe and analyze it from different angles.

Visualising forces us to make decisions about a problem that words alone don’t. We have to decide where to place each element, decide on its shape, size, its boldness, and color. We have to decide what we sketch and what we write. All these decisions require a deeper understanding of the problem and make important questions surface fairly quickly.

All in all, supporting your collaboration by making it more visual works like a catalyst for faster and better understanding.

Working in this way is obviously easier if your team is working in the same room. For distributed teams and freelancers, there are alternatives to communicate in ways other than words, e.g. by making a quick Screencast to demonstrate an issue, or even sketching and photographing a diagram can be incredibly helpful. There are collaborative tools such as Milanote, Mural, and Niice; such tools can help with the process Eva-Lotta described even if people can’t be in the same room.

Screenshot of the Niice website

Niice helps you to collect and discuss ideas

I’m very non-visual and have had to learn how useful these other methods of communication are to the people I work with. I have been guilty on many occasions of forgetting that just because I don’t personally find something useful, it is still helpful to other people. It is certainly a good idea to change how you are trying to communicate an idea if it becomes obvious that you are talking at cross-purposes.

Over To You

As with most things, there are many ways to work together. Even for remote teams, there is a range of tools which can help break down barriers to collaborating in a more visual way. However, no tool is able to fix problems caused by a lack of respect for the work of the rest of the team. A good relationship starts with the ability for all of us to take a step back from our strongly held opinions, listen to our colleagues, and learn to compromise. We can then choose tools and workflows which help to support that understanding that we are all on the same team, all trying to do a great job, and all have important viewpoints and experience to bring to the project.

I would love to hear your own experiences working together in the same room or remotely. What has worked well — or not worked at all! Tools, techniques, and lessons learned are all welcome in the comments. If you would be keen to see tutorials about specific tools or workflows mentioned here, perhaps add a suggestion to our User Suggestions board, too.

Smashing Editorial
(il)

Continuous Learning of Your iOS App Using App Center

Original Source: https://www.sitepoint.com/continuous-learning-ios-app-using-app-center/

This article was created in partnership with Microsoft. Thank you for supporting the partners who make SitePoint possible. App development is an iterative process, the work you do on version 2 of an app is largely based on the things you learned from building and releasing version 1. In order for your development efforts to […]

Continue reading %Continuous Learning of Your iOS App Using App Center%

Famous logos redesigned as fonts

Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/XFYT2HoHg9Q/famous-logos-redesigned-as-fonts

A good logo design often depends on a good typeface. If you get it right, the perfect font choice can become synonymous with a brand. To show how a strong identity can remain recognisable even when you swap out the brand name, designer and teacher Emanuele Abrate has been conducting a series of interesting logo experiments.

In his experiments, Abrate has swapped out the names of brands like Adidas and YouTube for the names of the fonts they use. Speaking to Co. Design, he revealed that the project came about as he struggled to identify the typeface in a logo. "Every time I see a logo, I wonder how it was conceived, how it was designed, what kind of typeface was used and why."

The results will make you double-take. In most cases, our eyes have become so used to the font styles and logo graphics that we'll just glaze over when looking at a design that looks recognisable enough. Take a look at them by scrolling left to right with the arrow icons in the gallery below.

Related articles:

The rules of responsive web typography5 typography trends for 201850 top typography tutorials

An Introduction to Gulp.js

Original Source: https://www.sitepoint.com/introduction-gulp-js/

Developers spend precious little time coding. Even if we ignore irritating meetings, much of the job involves basic tasks which can sap your working day:

generating HTML from templates and content files
compressing new and modified images
compiling Sass to CSS code
removing console and debugger statements from scripts
transpiling ES6 to cross-browser–compatible ES5 code
code linting and validation
concatenating and minifying CSS and JavaScript files
deploying files to development, staging and production servers.

Tasks must be repeated every time you make a change. You may start with good intentions, but the most infallible developer will forget to compress an image or two. Over time, pre-production tasks become increasingly arduous and time-consuming; you’ll dread the inevitable content and template changes. It’s mind-numbing, repetitive work. Wouldn’t it be better to spend your time on more profitable jobs?

If so, you need a task runner or build process.

That Sounds Scarily Complicated!

Creating a build process will take time. It’s more complex than performing each task manually, but over the long term, you’ll save hours of effort, reduce human error and save your sanity. Adopt a pragmatic approach:

Automate the most frustrating tasks first.
Try not to over-complicate your build process. An hour or two is more than enough for the initial setup.
Choose task runner software and stick with it for a while. Don’t switch to another option on a whim.

Some of the tools and concepts may be new to you, but take a deep breath and concentrate on one thing at a time.

Task Runners: the Options

Build tools such as GNU Make have been available for decades, but web-specific task runners are a relatively new phenomenon. The first to achieve critical mass was Grunt — a Node.js task runner which used plugins controlled (originally) by a JSON configuration file. Grunt was hugely successful, but there were a number of issues:

Grunt required plugins for basic functionality such as file watching.
Grunt plugins often performed multiple tasks, which made customisation more awkward.
JSON configuration could become unwieldy for all but the most basic tasks.
Tasks could run slowly because Grunt saved files between every processing step.

Many issues were addressed in later editions, but Gulp had already arrived and offered a number of improvements:

Features such as file watching were built in.
Gulp plugins were (mostly) designed to do a single job.
Gulp used JavaScript configuration code that was less verbose, easier to read, simpler to modify, and provided better flexibility.
Gulp was faster because it uses Node.js streams to pass data through a series of piped plugins. Files were only written at the end of the task.

Of course, Gulp itself isn’t perfect, and new task runners such as Broccoli.js, Brunch and webpack have also been competing for developer attention. More recently, npm itself has been touted as a simpler option. All have their pros and cons, but Gulp remains the favorite and is currently used by more than 40% of web developers.

Gulp requires Node.js, but while some JavaScript knowledge is beneficial, developers from all web programming faiths will find it useful.

What About Gulp 4?

This tutorial describes how to use Gulp 3 — the most recent release version at the time of writing. Gulp 4 has been in development for some time but remains a beta product. It’s possible to use or switch to Gulp 4, but I recommend sticking with version 3 until the final release.

Step 1: Install Node.js

Node.js can be downloaded for Windows, macOS and Linux from nodejs.org/download/. There are various options for installing from binaries, package managers and docker images, and full instructions are available.

Note for Windows users: Node.js and Gulp run on Windows, but some plugins may not install or run if they depend on native Linux binaries such as image compression libraries. One option for Windows 10 users is the new bash command-line, which solves many issues.

Once installed, open a command prompt and enter:

node -v

This reveals the version number. You’re about to make heavy use of npm — the Node.js package manager which is used to install modules. Examine its version number:

npm -v

Note for Linux users: Node.js modules can be installed globally so they’re available throughout your system. However, most users will not have permission to write to the global directories unless npm commands are prefixed with sudo. There are a number of options to fix npm permissions and tools such as nvm can help, but I often change the default directory. For example, on Ubuntu/Debian-based platforms:

cd ~
mkdir .node_modules_global
npm config set prefix=$HOME/.node_modules_global
npm install npm -g

Then add the following line to the end of ~/.bashrc:

export PATH=”$HOME/.node_modules_global/bin:$PATH”

Finally, update with this:

source ~/.bashrc

Step 2: Install Gulp Globally

Install Gulp command-line interface globally so the gulp command can be run from any project folder:

npm install gulp-cli -g

Verify Gulp has installed with this:

gulp -v

Step 3: Configure Your Project

Note for Node.js projects: you can skip this step if you already have a package.json configuration file.

Presume you have a new or pre-existing project in the folder project1. Navigate to this folder and initialize it with npm:

cd project1
npm init

You’ll be asked a series of questions. Enter a value or hit Return to accept defaults. A package.json file will be created on completion which stores your npm configuration settings.

Note for Git users: Node.js installs modules to a node_modules folder. You should add this to your .gitignore file to ensure they’re not committed to your repository. When deploying the project to another PC, you can run npm install to restore them.

For the remainder of this article, we’ll presume your project folder contains the following sub-folders:

src folder: preprocessed source files

This contains further sub-folders:

html – HTML source files and templates
images — the original uncompressed images
js — multiple preprocessed script files
scss — multiple preprocessed Sass .scss files

build folder: compiled/processed files

Gulp will create files and create sub-folders as necessary:

html — compiled static HTML files
images — compressed images
js — a single concatenated and minified JavaScript file
css — a single compiled and minified CSS file

Your project will almost certainly be different but this structure is used for the examples below.

Tip: If you’re on a Unix-based system and you just want to follow along with the tutorial, you can recreate the folder structure with the following command:

mkdir -p src/{html,images,js,scss} build/{html,images,js,css}

Step 4: Install Gulp Locally

You can now install Gulp in your project folder using the command:

npm install gulp –save-dev

This installs Gulp as a development dependency and the “devDependencies” section of package.json is updated accordingly. We’ll presume Gulp and all plugins are development dependencies for the remainder of this tutorial.

Alternative Deployment Options

Development dependencies are not installed when the NODE_ENV environment variable is set to production on your operating system. You would normally do this on your live server with the Mac/Linux command:

export NODE_ENV=production

Or on Windows:

set NODE_ENV=production

This tutorial presumes your assets will be compiled to the build folder and committed to your Git repository or uploaded directly to the server. However, it may be preferable to build assets on the live server if you want to change the way they are created. For example, HTML, CSS and JavaScript files are minified on production but not development environments. In that case, use the –save option for Gulp and all plugins, i.e.

npm install gulp –save

This sets Gulp as an application dependency in the “dependencies” section of package.json. It will be installed when you enter npm install and can be run wherever the project is deployed. You can remove the build folder from your repository since the files can be created on any platform when required.

Step 4: Create a Gulp Configuration File

Create a new gulpfile.js configuration file in the root of your project folder. Add some basic code to get started:

// Gulp.js configuration
var
// modules
gulp = require(‘gulp’),

// development mode?
devBuild = (process.env.NODE_ENV !== ‘production’),

// folders
folder = {
src: ‘src/’,
build: ‘build/’
}
;

This references the Gulp module, sets a devBuild variable to true when running in development (or non-production mode) and defines the source and build folder locations.

ES6 note: ES5-compatible JavaScript code is provided in this tutorial. This will work for all versions of Gulp and Node.js with or without the –harmony flag. Most ES6 features are supported in Node 6 and above so feel free to use arrow functions, let, const, etc. if you’re using a recent version.

gulpfile.js won’t do anything yet because you need to …

Step 5: Create Gulp Tasks

On its own, Gulp does nothing. You must:

install Gulp plugins, and
write tasks which utilize those plugins to do something useful.

It’s possible to write your own plugins but, since almost 3,000 are available, it’s unlikely you’ll ever need to. You can search using Gulp’s own directory at gulpjs.com/plugins/, on npmjs.com, or search “gulp something” to harness the mighty power of Google.

Gulp provides three primary task methods:

gulp.task — defines a new task with a name, optional array of dependencies and a function.
gulp.src — sets the folder where source files are located.
gulp.dest — sets the destination folder where build files will be placed.

Any number of plugin calls are set with pipe between the .src and .dest.

Continue reading %An Introduction to Gulp.js%

Editorial Design: Centuro Cultural Jardín Japonés

Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/a0lP6ywyQ60/editorial-design-centuro-cultural-jardin-japones

Editorial Design: Centuro Cultural Jardín Japonés

Editorial Design: Centuro Cultural Jardín Japonés

AoiroStudio
Apr 23, 2018

Let’s kick it off with a beautiful branding & editorial design by Angello Torres who is a graphic designer from Buenos Aires, Argentina. Ver Para Oír / Jardín Japonés translated to See To Hear / Japanese Garden and I simply love this project. The mixture of the culture, colours and you just gotta love that font Avant Garde who has been my go-to font for years. Check it out, this project is beautifully shown in execution and presentation.

Seeing To hear is a festival carried out within the cultural framework offered by the Japanese Garden, in which the senses of sight and hearing merge crossing each other generating new forms of perception, carried out from different sound activities and visuals. “hear colors, perceive sounds and observe silence”

More Links
Learn more about Angello Torres
Editorial Design & Branding
Editorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín JaponésEditorial Design: Centuro Cultural Jardín Japonés

editorial design
graphic design


Sharing Code Between Projects: Lessons Learned In The Trenches

Original Source: https://www.smashingmagazine.com/2018/04/sharing-code-between-projects/

Sharing Code Between Projects: Lessons Learned In The Trenches

Sharing Code Between Projects: Lessons Learned In The Trenches

Jonathan Saring

2018-04-25T14:40:51+02:00
2018-04-25T13:20:26+00:00

About a year ago, we came to a crossroad that changed the way we build software today. Like many other teams, we were working on a few things at a time, developing different projects for our web and mobile applications, with shared ingredients in the form of common Node.js code between our back-end repositoriess and microservices, and common React UI components with some slight visual and functional differences between our apps.

As our team grew and code lines multiplied, we began to realize that with every passing day we were writing the same code over and over again. Over time, it became harder to maintain our code base and develop new features with the same speed and efficiency.

Finally, we decided to find a solution that would enable us to share and sync common components of code between our projects. Here is what we learned along our journey, which eventually gave birth to Bit.

Sharing code components between projects

Code components as building blocks. (Large preview)

What if there was a web conference without… slides? Meet SmashingConf Toronto 2018 ?? with live sessions exploring how experts work behind the scenes. Dan Mall, Lea Verou, Sara Soueidan, Seb Lee-Delisle and many others. June 26–27. With everything from live designing to live performance audits.

Check the speakers →

SmashingConf Toronto 2018, with Dan Mall, Sara Soueidan, Lea Verou and many others.

Common Code In The Wild

While Git is great for collaborating on a single repository, sharing code between multiple projects can be more challenging than we think.

To get started, we looked into our own code base to learn how many times we duplicated our own integration to our user service. The unbelievable result was no less than 86 instances. After the initial shock, we started thinking that this must also be happening elsewhere.

Code shared in multiple projects

Using the same code in different places. (Large preview)

We asked some friends working in a few different organizations of various sizes to run a simple copy-and-paste detection on their code base, looking for duplicates of code longer than 100 lines. The result blew us away: On average, more than 30% of their code base was duplicated.

Finally, we decided to look deep into the open-source projects on GitHub, checking for both duplications and re-implementations of a simple isString function in the 10,000 most popular JavaScript GitHub projects.

Amazingly, we found this function was implemented in more than 100 different ways and duplicated over 1,000 times in only 10,000 repositories. Later studies claim that over 50% of the code on GitHub is actually duplicated. We realized we were not the only ones facing this issue.

Looking For A Solution

Before building Bit, we looked for a tool that would help us turn the smaller components that our apps are built from into building blocks that could be shared between our projects and synced across our code base. We also wanted to organize them and make them discoverable for our team. Here’s a short summary of what we learned.

A Micro-Package Arsenal With NPM

At first, we considered publishing all of our UI components, utility functions and smaller modules as packages to NPM. This seemed like the obvious solution for modularity for our software’s building blocks. However, we quickly learned that this solution came with huge overhead.

Trying to publish a few files from our project to NPM forced us to split our repository and create new ones just to share this code. When dealing with hundreds of components, this meant having to maintain and make changes across hundreds of repositories.

We would also have to refactor our code base, removing the newly created packages from their original repositories, boilerplating the packages in the new repositories and so on.

Even then, we had now a simple way to organize these packages and make them easily discoverable to our entire team. Another major problem was the coupling between the packages and the owners of their origin repositories, which made it nearly impossible for other people to quickly make updates to the packages while working on their own projects.

This kind of overhead was too much for us to handle. So, we quickly decided to look for a better way to share our code.

Lerna Monorepos

The next option we came up with was to use Lerna in order to refactor our code base into a few multi-package repositories, often referred to as “monorepos”.

The Hydra of Lerna

Lerna multi-package repository. (Large preview)

The upside of this solution was that it would allow us to maintain and publish all our packages from a single repository. However, this option, too, came with a set of drawbacks, particularly when working with smaller components.

Choosing this option meant we would still have to effectively keep multiple packages with multiple package.json files, multiple build and test environments and a complicated dependency tree to handle between them. Updating these packages must also go through the main repository, still making it hard to modify these package from other projects when working with a few separate monorepos.

For example, take the popular Material-UI React UI library. Even though it uses Lerna to publish five different packages from the same repository, you would still have to install the entire library to use each of its components. Making changes would still have to go through that project as well, and discoverability for these component didn’t improve.

Monorepos can be great for some cases (such as testing or building a project as a whole) and can definitely work for some teams. However, refactoring your entire code base just to share common code between projects while still having to struggle with the issues mentioned above made us drop this option as well.

Shared Libraries

This option was quickly dropped, too. In a lot of way, it resembles using a CD-ROMs instead of an iTunes playlist. First, it made no sense to force an entire library of React components and an entire utility library and so on on each of our projects.

Secondly, every project using it would be tightly coupled to the development of this library, making it impossible to adjust its components for each project. This becomes most painful when sharing common Node.js code between our microservices, which would now be coupled to the library.

Thirdly, discoverability within the library is bound to be poor and would involve a lot of work with its documentation and usage in different edge cases.

Because it makes very little sense to couple and slow down our development, we try to minimize the use of these libraries as much as possible. Even popular JavaScript utility libraries such as Lodash are working hard to make their smaller components independently available via NPM.

Git Submodules

Finally, we turned back time and looked into working with Git submodules.

You there. You're thinking about using a Git submodule. DON'T. Just don't. It's not worth it, ever.

— Jeremy Kahn (@jeremyckahn) December 16, 2012

Git enables you to make one repository a subdirectory of another repository, creating a single working tree for the entire project, so that a repository can utilize code from another repository.

As for many other teams, this solution did not last for us. First, submodules only work on the master branch, which causes problems for rapid development. Secondly, submodules increase coupling between projects, which makes it hard to work on cross-repository assignments. Finally, a submodule repository is oblivious to its own nesting and the existence of dependent repositories.

After trying these different solutions, we realized that it shouldn’t be this complicated. There really should be a simpler way to organize, share and develop components of code from different projects. So, we decided to build it, and called it Bit.

Building Bit

Our vision for a solution was simple: turn our components and modules into building blocks that can be easily isolated from any project, organized in the cloud and used in any project.

Bit sharing workflow

Isolate, share and organize your reusable code. (Large preview)

When building it, we set a few guidelines for what we needed from the project.

Make it seamless to isolate and share code components from any project, without having to create new repositories or manually configure build and test environments and dependencies for each component.
Enable two-way development, so that each component could be changed and updated from any project, while changes would be synced across our code base.
Make it simple to organize and share our components, while making them discoverable for our entire team with useful visual information.

After hard work and extensive research, in 2017 we released the first version of Bit to GitHub.

How It Works

Bit’s workflow is made of three simple steps:

The first is to simply tell Bit which components of code you would like to share from your project, and it will immediately start tracking them in all of the projects you share them in.
You can then tag a version for these components so that Bit automatically defines and locks their dependency tree for both file and package dependencies, and creates an isolated environment for each component to build and test in isolation.
Finally, you can share the components to the cloud (or your own remote server), where they will be organized, will be made discoverable and can be installed with NPM or Yarn like any other package.

You don’t have to create new repositories, split your code base or refactor a single line of code.

Now comes the really cool part. You can also use Bit to import the components into other projects for further development. Because Bit tracks your components between projects, you can simultaneously develop them from different repositories and sync changes across your code base.

This fast and distributed workflow means you won’t be tied by ownership issues, and you can actually develop the shared code and update changes from any of your team’s projects.

Let’s see an example.

Example: Bit With React UI Components

A React Hero component with Bit

A React Hero component with Bit. (Large preview)

For this example, let’s pick a common use case: syncing React UI components between apps. Although designed to be reusable, achieving such reusability can be challenging.

Let’s take an example React app on GitHub. It contains eight reusable React UI components and one global styling component. As you can see, Bit was added to the repository (see the bit.json and .bitmap files) to track these components — but not a single line of code was changed in the repository. From there, the components were shared to the corresponding scope on Bit’s free web hub.

As you can see, each of the components is now available to any developer to install with NPM or Yarn or to import into their own projects for further development.

All of the components are organized and can be shared with your team and searched for via a search engine. They are presented with visual rendering, build and test results (you can use premade external build and test environments or create your own), and come with auto-parsed docs so that you can make an informed decision on which components to use.

Once it’s changed from a different project, you can update the component’s version in the scope (which works as a remote source of truth) and sync changes between different repositories.

A short tutorial for React is available for the example project.

Conclusion

Sharing code between projects is vital to building software faster, while making your code base simpler to maintain and develop over time. As more of our applications are built using reusable components such as React and Vue UI components, Node.js modules, simple functions, GraphQL APIs and more, turning them into building blocks for different projects becomes more rewarding.

However, the overhead of splitting repositories, refactoring projects, and modifying components from different projects can make it hard to effectively collaborate and share your code. These are the lessons learned from our own journey towards simple and effective code sharing, making it simpler to share, discover and collaborate as a team while building with our common LEGO bricks.

Bit is an open-source project, so feel free to jump in, suggest feedback or ask anything. Just remember that, at the end of the day, sharing code is always about people and about growing a collaborative culture where people play together to build great things.

Smashing Editorial
(rb, ra, al, yk, il)

Recognizing and Avoiding Common Web Design Mistakes

Original Source: http://feedproxy.google.com/~r/1stwebdesigner/~3/t0ySkwadXN4/

When you design your own website, several unexpected hurdles start to emerge. You might have trouble working with custom code, or maybe your site isn’t getting the number of visitors you need. Sometimes you start to realize that the design doesn’t look all that modern, or maybe the site speed isn’t up to your standards.

More often than not, you encounter these problems after committing one of the more common web design mistakes. These are so common that even experienced web designers make them. But it’s a good idea to address these issues ASAP, so you can fix them and make your site more appealing.

So, what are the most common web design mistakes? Let’s take a look:

Making the Site Too Confusing and Cluttered

Modern, minimalist sites are all the rage today – but it’s not just a fad. There was once a time when more was considered better, where you would build a website with eye-catching flash animations and cover each page with images and text. Fortunately, we’ve learned that people are more interested in finding information fast online. They’re not interested in sifting through a confusing homepage or waiting to watch an animation or video before moving forward.

The bottom line is that your menu should have as few tabs on it as possible. It should be easy to find, and you should consider finding some beta testers to see how quickly they can move through your site. This way, you can also get feedback from real people before launching.

Making the Site Too Confusing and Cluttered

Utilizing a Poor Call-to-Action (Or None at All)

With those beta testers, you’ll quickly find out whether or not users are converting – and how fast. For instance, you might instantly realize that you don’t have a call-to-action header and button on the homepage. In that case, your users have nowhere to go. Even if you do have a call-to-action, it’s essential to constantly A/B test things like text, button colors, sizes and placement. This will give you an an idea of how people react to the CTA. Heatmaps are excellent tools for this as well.

Utilizing a Poor Call-to-Action (Or None at All)

Favoring Design Over Speed

It might sound strange to think about speed as being more important than design, but you’re not going to get many visitors to a beautiful website if it runs too slowly. Hosting has quite a bit to do with the speed of your site, so find a hosting company that can handle your traffic. In addition, you’ll want to utilize plugins, extensions and themes that are well-coded and lightweight. There’s nothing worse than choosing a theme and realizing that it’s conflicting with your site’s code or forcing your site to run slowly.

Favoring Design Over Speed

Ignoring the Needs of Mobile Devices

Since so many people use mobile devices to browse and shop online, many experts feel that a mobile-version of your site is almost more important than the regular desktop version. This means that your finished website needs a mobile version that automatically loads when a smaller device is detected. This not only makes your users happier when on phones and tablets, but Google will notice the mobile version and potentially improve your search rankings. If you’re working from a theme, make sure you test out the mobile version before buying. Most developers claim they have responsive designs, but that doesn’t mean they look or work well.

Ignoring the Needs of Mobile Devices

Filling Pages with Too Much Text

Text is great for headlines and for giving your users (as well as search engines) valuable information. However, you’re better off trying to get your message across with a combination of media and text. Think about how the experience would be more pleasant with a small paragraph paired with a video, followed by some pictures. Compare this with a homepage that consists of three or four paragraphs in a row, and it’s clear which one works best.

Filling Pages with Too Much Text

Rules to Live (And Design) By

Some rules are meant to be broken. But, most of the time, you can bet that if you avoid these mistakes you’ll be well on your way to a quality web design. If you have any questions, or would like to mention any other common web design mistakes, let us know in the comments below.


Freebie: 100 Awesome Photos from Moni’s Photo

Original Source: https://inspiredm.com/freebie-100-awesome-photos-from-monis-photo/

Moni is a young artist who loves photography. On Moni’s Photo you can download all the photos for free and use them for your personal and commercial projects.  Moni’s Photo covers various topics from business and technology to nature, animals and more.

All photos are licensed under the Creative Commons Zero (CCO) license which means you can copy, modify, distribute and use them for free, including commercial purposes.

Download the best 100 photos beneath the previews.

Get the free photo pack from here.

The post Freebie: 100 Awesome Photos from Moni’s Photo appeared first on Inspired Magazine.

A Beginner’s Guide to Video SEO

Original Source: https://www.webdesignerdepot.com/2018/04/a-beginners-guide-to-video-seo/

The popularity of video content has increased dramatically over the last few years and it’s easy to see why; videos are engaging for all age groups which also makes them an important marketing tool.

Businesses have developed dedicated video marketing strategies which generate more leads and boost sales. Video content is also being used by these same businesses to build a better brand experience and stand out from rest of the competition.

And while it’s entirely possible to create high-quality video content and share it through platforms like YouTube, there’s no guarantee that your video will get noticed by the masses. Why? There’s an enormous amount of video content being uploaded to the Internet every day.

In this post, we’ll step through five ways you can optimize your videos for search engines. By the time you’re done reading through this post, you’ll have a clear understanding of how you can implement video SEO techniques to improve your search rankings and reach a bigger audience.

Before we begin, let’s quickly take a look at the basics of video SEO and why it’s important.

What You Need to Know About Video SEO

The fact of the matter is that most consumers search the web when making purchase decisions. So, if you want to take advantage of video marketing, your videos should be optimized for search engines. Video Search Engine Optimization (video SEO) techniques are used by successful video content creators to improve their search engine rankings and increase visibility in search engine results pages.

Nowadays, it’s pretty common to see people consuming video content on their phones at sports events, walking around campus, doing chores around the house, and during their daily commute. Why is that so?

According to Cisco:

Every second, a million minutes of video content will cross the network by 2021.
Globally, IP video traffic will be 82 percent of all consumer Internet traffic by 2021, up from 73 percent in 2016.
It would take an individual more than 5 million years to watch the amount of video that will cross global IP networks each month in 2021.

Think about it for a minute. That is an estimate of enormous proportions. You might be thinking What has this got to do with video SEO? Well, SEO itself is just one important component of digital marketing. The other crucial element is converting your video content traffic into paying customers. Videos can be the perfect tool to help you do just that.

If you want to take advantage of video marketing, your videos have to be optimized for search. Here is how you can drive more traffic to your video content and make your video search results more visible while generating quality leads.

5 Ways You Can Optimize Videos for Search Engines

Over the years, there has been a considerable increase in the usage and popularity of video. They help explain complex topics in a simple way and they play an integral role in increasing conversion rates. Your decision to adopt video as your go-to digital marketing tool is going pay you serious dividends—assuming you optimize your video content for search.

It’s pretty easy to see that video is gaining momentum. Let’s step through some of the different ways you can use video SEO to stay ahead of your competition.

1. Search for Video SEO Keywords

You’ve probably noticed that Google has been displaying more and more videos in search results—a huge chunk of it coming from, to no one’s surprise, YouTube. Video publishing sites like YouTube and Vimeo are huge sources of traffic that receive higher click-through rates than plain text results.

Keywords are responsible for search results displayed on two of the largest search engines on internet—Google and YouTube. For this reason, if you want your video to be successful, you’ll have to use keywords. But how do you find keywords?

If, for instance, you’re in the web design niche, you could start out by running Google searches on terms like web design tutorials or web design tips and tricks.

Now that you have a good keyword to start out with, the next step is to check its search volume. We recommend using the Google Keyword Planner for this. Keywords that get anywhere from 1,000 to 10,000 monthly searches and have low to medium competition are generally good to use.

2. Optimize Metadata: Tags, Filenames, and Descriptions

Tags are keywords assigned to videos. Think of them as the set of words that sum up what your video’s content is about. For those of you who don’t already know, tags, filenames, and descriptions play an integral role in video SEO.

Since you already have a keyword picked out, go ahead and use that in your video’s tags. This is the tag that you want to focus on and optimize your video for. Remember, you can (and should) use more than one tag as long as it’s relevant to your video’s content.

YouTube gives you 5,000 characters worth of description text that you can use to describe what your video is about. And if you’re not using those 5,000 characters to gain some SEO advantage then you’re missing out. Best practices indicate that you should use your keyword (the same one you used as your primary tag) a few times in your video’s description.

Finally, make sure you save your video with your primary keyword as its filename because there are a number of third-party tools on the web that crawl through and factor in video filenames even if Google and YouTube don’t. So, instead of saving the original video file as vid1.mp4 or youtube-vid.mp4, use your primary keyword in its filename. For example, we’d save the video as web-design-tips-and-tricks.mp4.

3. Add a Video Transcript

Video transcripts are a complete textual representation of the content spoken in the video. Metadata and video tags do not offer as much detail of your video’s content to search engines as transcriptions do. Search engine bots crawl text and use it for indexing. So, a video transcript helps search engines better understand the video’s content and improve its ranking.

Follow these steps to transcribe your own video files on YouTube:

Your transcription file should be saved as a plain text file i.e. .txt.
Using special characters can disrupt speech recognition matching and readability of the transcript.
A double line break should be used to signal long pause or new sentence.
Add >> at the start of the new line to identify speakers or change of speaker.
Insert a link to your website in the audio transcript at the end of the video.

Taking this DIY approach to transcribing your video content will help you deliver more value to your viewership by improving their user experience and it’ll give you the opportunity to use the primary keyword you’re targeting for, a few more times.

4. Publish One Video to One Page

Give each video its own dedicated page on your website instead of publishing multiple videos to a single page. Google gives preference to the first video it finds on a web page and ignores any other video content it finds on the same page. To work your way around Google’s video ranking preference, organize your web pages in a way so that there’s a single video on a page (or post).

You might also be tempted to publish the same video to different web pages on your site to increase its visibility; for instance, if your video is about web design tips and tricks then you might want to publish it in a blog post that you wrote about web designs tips, and you might also want to show it to visitors who land on your Projects page to showcase your ability; this is a strict no-no.

What this does is that it creates internal competition on your website for each instance of the video that you’ve published. Think of it this way, when someone searches for web design tips and tricks on Google, Google’s algorithm has to decide which page to display in its search results. And if all of your videos views are split among three different web pages, your chances of showing up in the search results will be pretty low. However, if you had published it on a single page, and that page was racking up all the views, comments, and impressions, then you’d have a better chance of showing up in search results.

5. Create a Video Sitemap

Video sitemaps provide search engines with metadata about video content on a website and are an extension to your website’s existing sitemap.

You can use the sitemap to tell search engines about the category, title, description, length, and target audience for each video you embed on your website. In addition to this, you can also use it to give search engines more information about your video e.g. play page URL, expiration date, restrictions, and platform.

If your web page has a video on it then it’s sitemap may look something like this:

Conclusion

Video content is gaining momentum.

There are a number of different ways that you can use video SEO tips to increase your video’s visibility, improve its ranking, and show up in search engine results pages. We showed you some of the ways you can get started with video SEO on your own website and, hopefully, you’re in a good position to take things further.

Add Realistic Chalk and Sketch Lettering Effects with Sketch’it – only $5!

Source

p img {display:inline-block; margin-right:10px;}
.alignleft {float:left;}
p.showcase {clear:both;}
body#browserfriendly p, body#podcast p, div#emailbody p{margin:0;}