Original Source: https://www.hongkiat.com/blog/interesting-facts-about-google/
Google is the most visited website on the planet, but you already knew that, right? However, do you know that Google does 65k+ searches every second? And it is not the only fascinating fact about…
Visit hongkiat.com for full content.
Original Source: https://www.smashingmagazine.com/2018/07/writing-code-poems/
Learning To Code By Writing Code Poems
Learning To Code By Writing Code Poems
Murat Kemaldar
2018-07-11T14:00:32+02:00
2018-07-17T15:48:55+00:00
Back in 2008, I started studying design and clearly remember how the sheer sight of code just intimidated me. I had some coding classes, and without any prior coding experience, I had a tough time understanding the code I first got in touch with. Suddenly, the words that I was used to in the English language (such as “new,” “return” and “throw/catch”) took on a whole new meaning; the cryptic syntax, semicolons, brackets and completely new rules didn’t make things any easier for me.
If you are new to JavaScript and/or have struggles adding it to your skillset, I may have an approach for you to overcome those barriers. You are definitely not alone, and you have every right to think that learning to code is a tough nut to crack.
Why Is Learning To Code So Tough?
Here are some of the misconceptions about why I think people are having a hard time learning or getting interested in JavaScript (or any coding language):
Code is cryptic, purely functional and scary;
Code is meant for machines only, so people do not feel addressed or engaged;
Code is not treated as a language because it has a completely different use case and looks very different from anything they have seen before;
People think of stereotypes (evil hackers, maybe some Matrix dudes), and thus do not identify themselves with it.
Nope, we can’t do any magic tricks, but we have articles, books and webinars featuring techniques we all can use to improve our work. Smashing Members get a seasoned selection of magic front-end tricks — e.g. live designing sessions and perf audits, too. Just sayin’! 😉
Explore Smashing Wizardry →
Me, before any contact with code (Large preview)
As a developer, you are expected to treat code in a very specific way — even to think in a quite different (and highly logical) way. Coding languages are quite strict and intolerant; a single character can make the machine fail to understand what you mean and make applications crash. You are expected to ignore and override certain things you know from speaking and writing a human language (which is, by the way, also the case when learning a new human language).
But not all programming languages, documentations or tutorials on the web are made with this “human to programming language transition” in mind. Of course, they don’t have to. After all, the main purpose of code is to tell machines what to do.
Still, due to that purpose, a chance for comparison is simply missing and the languages you speak (vocabulary and rules) seem to be rendered useless for learning a programming language. There is no word for “love” in the JavaScript language, nor does it make sense to say “I love you.” A machine (or browser) simply does not know or care about love (yet?). This “completely new” and “don’t know where to start” feeling can be scary as hell.
Me, after my first contact with code. (Large preview)
This is why I am here. I think that you can learn JavaScript in a much easier and artistic fashion, by holding on to your human language knowledge, and by treating JavaScript like any other human language. Let me demonstrate with a small example.
Fun fact: Some programming languages actually have the transition from one programming language to another in mind. This is why it is so much easier to learn a lot of programming languages — just by learning a single one.
A Small Example
In a lot of cases, when you want to execute JavaScript code, you want the “document” (basically the website, a user is downloading on each visit) to be ready so that you can interact with HTML elements, for example. In pure JavaScript, you may stumble over something this:
(function() {
// Your code goes here
})();
(Yuck! ? In this case, a function is defined in brackets, and then immediately called with another pair of brackets at the end. This is referred to as an IIFE.)
Or sometimes like this:
if (document.readyState === ‘complete’) {
// Your code goes here
}
The first snippet definitely requires an explanation, while with the second (and maybe some fantasy), one could comprehend that there is a condition which needs to be fulfilled so that something else happens just by just looking at it.
Imagine something like this, though:
onceUponATime(function () {
// Your code (story) goes here
})
“Once upon a time” is something (dare I say) even a child might understand. It addresses the developer (by referring to childhood memories), while theoretically doing the same thing. This is what I consider “having the human to coding language transition” in mind.
Quick note on “functions“: A function is basically a skill, which is dormant until you call upon it. “To read” is a skill function read() { … }, which is called upon when you are want to read something like this: read(). There is also something called “anonymous functions”, i.e. "function() { … } (has no name, like in the snippets above) which are basically “one-time / casual actions” that you wouldn’t consider to be a skill, such as “to push a button.”
Turning The Tables: From Message To Basics
So let’s take this idea a bit further. Let’s take the reasons and misconceptions above, and turn them upside-down:
A small poem.
Written in JavaScript.
Made for human beings.
About the love between two individuals.
// Love at first sight
if (me.getDistanceTo(you.position) < 200) {
me.setFeelings({
inLove: true,
});
}
It is not functional. It is currently not meant for machines. It is meant for you to read and understand.
If you got the message of the poem, you actually understood a piece of JavaScript code, which you might have compared to the English language.
Now you might ask yourself: I understand this, but why is it written like this? What are the rules (grammar) of this language? What is the meaning of “me” (in a technical sense), and why does this code look so similar to English?
Rules, Vocabulary, And Variables
One of the most important things to understand when learning a programming language is the concept of variables.
Every human language has its rules (grammar) and a lot of vocabulary (pre-defined). Obviously, both of these first need to be learned in order to be able to speak the language.
JavaScript, like many other programming languages, also comes with its own set of rules (e.g. the . between the words or how if statements are written) and its own vocabulary (if, document, window, Event, and so on). These keywords are reserved (or ‘pre-defined’) by JavaScript (and the browser), and each one of them has its specific purpose.
But like I mentioned earlier, a chance to compare the words and sentences you know from the English language is seemingly missing because there are no equivalents.
This is where variables come in; you (the developer) can (or even have to) define the variables in order to make machines and developers understand what something stands for. Variables can take a lot of forms (hence the name): They can be a chain of words and letters (strings), a number, an action (function), or even a collection (array). You name it.
In all languages, there is probably a word for love. You kinda know what it means, but not really, because it is so subjective. But still, there is a word for it.
But in JavaScript, there is no “love,” until you say there is. It can be whatever you want it to be.
var love = {
color: ‘red’,
duration: 365,
loveTarget: ‘cats’,
};
// a simple variable expression,
// where love is an object “{ … }”, a thing
// with some properties (color, duration, loveTarget).
const love2 = {
color: ‘purple’,
duration: ‘forever’,
loveTarget: ‘dogs’,
};
// also a variable expression, where love2 (a constant),
// cannot be redefined / overwritten completely:
// love2 = undefined; // => will not work
// (“undefined” is a pre-defined javascript keyword,
// basically saying “has no value”)
It is crucial to be able to distinguish between what is pre-defined in JavaScript (JavaScript rules and vocabulary), and what is actually custom defined by the developer (also known as ‘application logic’ or ‘business logic’).
Returning to the poem written above:
// Love at first sight
if (me.getDistanceTo(you.position) < 200) {
me.setFeelings({
inLove: true,
});
}
These expressions come from the following JavaScript vocabulary/ruleset:
if (…) { … }
// if statement: when … is met, do things in { … }
{
inLove: true,
}
// an “object” with some info, some thing in the world.
// can contain other info, and “skills” (functions).
// “inLove” is a custom property,
// “true” is pre-defined in javascript, (meaning: “yes”)
// and the value of “inLove”.
.
// needed to access an objects property “my name: me.name”
getDistanceTo()
// an expression to “call” a function (a “skill”).
// getDistanceTo is custom (not JavaScript), and a function,
// so it can be executed / called upon with the “()” after.
// sometimes you can pass arguments in those brackets (like “position”)
// to change the outcome of a function.
And these are the variables (where you have free reign over defining their names and behavior):
me // an object, some thing in the world
you // an object, some thing in the world
position // an info about “you”, accessed by the “.”
getDistanceTo // a skill of me, accessed by the “.”
getDistanceTo() // the skill, with javascript grammar telling: do it.
getDistanceTo(position) // same, but do it with “position”.
setFeelings // another skill of me, accessed by the “.”
setFeelings({ inLove: true }); // the skill, with some instructions (an object).
Let’s assume the poem is now human-readable. You might have understood the message, you also might see the difference between JavaScript language rules you need to follow, and the things you actually have to come up with yourself (the variables).
But what about the machine?
If the machine (the browser) were to read this poem, it would throw an error. The machine needs a definition of “me” and “you” because it tries to access its properties (via the . in me.getDistanceTo()). With the distinction ability mentioned above, you can actually engineer “me” and “you” to make the poem executeable/machine-readable, like this:
// This is how the definition of a being (me/you) could look like
var me = {
position: {x: 0, y: 0} // some coordinates, maybe
getDistanceTo: function(position) {
// calculate the distance, relative to own position
},
setFeelings: function(feelings) {
// handle those feelings…
}
}
var you = {
position: {x: 0, y: 0} // some coordinates, maybe
}
// the poem itself
if (me.getDistanceTo(you.position) < 200) {
me.setFeelings({
inLove: true,
});
}
So what happened here?
We read a JavaScript poem, written with JavaScript “grammar” with the only goal to be understood by human beings.
After understanding the message, we distinguished between rules, vocabulary, and variables, to understand the structure of the poem (grammar and basics of JavaScript).
With that distinction, we engineered the rest of the poems variables, with JavaScript rules in order to make it runnable by a machine (in the browser).
This was possible, because we treated JavaScript just like the English language.
A Bigger Example: Interactive Code Poetry
This is how my personal project LoveBits came to be. LoveBits is a code learning/storytelling experience.
LoveBits: Code poetry project in JavaScript (Large preview)
It tries to get people interested in JavaScript/coding by:
Putting readability and human language first;
Combining code with an art the reader might already be familiar with.
Storywise, it is about two Bits (rectangular beings); one of the Bits (blueBit) is the romantic one and writes JavaScript love poems to the other Bit (purpleBit).
When you start LoveBits, you can select one of the multiple love poems (written in JavaScript). Each poem has a code snippet which is written in a way that it is supposed to be understood by people who are not even familiar with programming. The only requirement is the English language.
“Love at first sight” (actually one of the LoveBits poems), for example, is about these two Bits in which the blueBit basically says, “If I get close enough to your position, I will ‘set my feelings’ to inLove: true.”
The special thing about these poems though is that you can “run” or “play” them simply by pressing the “play” button below. In the case of “Love at first sight,” you would see a blue and purple rectangle along with a number. As you might’ve already guessed, those are the two Bits mentioned in the poem, and the number below the blueBit is actually the distance between the blueBit and the purpleBit.
As the poem suggests, you may want to make the blueBit fall in love with the purpleBit by reducing the distance between them, right? So what can you do? You can interact and drag the blueBit around, and make it fall in love. But be careful, sometimes there is more than just one outcome.
One might actually say that you are the machine here. You’re the one who needs to interpret JavaScript code to be able to act and help two digital beings fall in love.
Where To Go From Here?
If you are a struggling developer, try treating JavaScript like a human language, and just understand what code snippets are supposed to do first instead of what they actually end up doing.
This is what I would recommend you to do next:
Always prefer going straight for examples and code for entire applications that combine rules, vocabulary, and variables together to form an application logic;
Application logic will tell the stories that will help you fill the gaps like in the code examples above. Code libraries and utilities such as lodash will only provide you with new vocabulary which will become helpful after being able to read and understand JavaScript code;
Review existing code, and try to break it down into small functions with names that reflect what they do. Write code which addresses humans and machines alike. Write code in such a way that it can be read like a sentence. Use comments wherever needed. Think about: How would I express this in a human language (to another developer)?
Conclusion
Learning to code can become easier once you start treating code as a human language and not as something aliens may have invented. Learning to distinguish between language features (built-ins) and variables/custom code for application logic is crucial. Being able to understand the application logic will put you in a powerful position to improve and change things, without even knowing language features.
Message before basics: Understand the message of any code snippet, and the basics of JavaScript will naturally follow. How many times have you heard someone say, “I understand the language, but I do not speak it yet”? It is a natural process, which can and maybe should be applied for learning both human and coding languages.
Also, always keep in mind that code has a clear functional purpose, but it does not always have to be like that. Even human languages were purely functional once, but then there came poems and even songs (JavaScript songs, anyone?), which connected people in entirely different ways. I think, or hope, that the same can apply here.
Always explore code projects, and perhaps even try writing a poem yourself (maybe even in another programming language you are familiar with)? I enjoyed creating the LoveBits project and would love to see some of your ideas in the comments below!
Further Reading
“If Hemingway wrote JavaScript,” Angus Croll
This is one of my favorite books which I actually stumbled upon after LoveBits. It’s about several famous poets and artists, and how they would have written JavaScript code snippets. It’s hilarious!
(rb, ra, il)
Original Source: https://www.sitepoint.com/building-ethereum-dapps-cross-contract-communication-token-selling/
In part 4 of this tutorial series on building DApps with Ethereum, we started building and testing our DAO contract. Now let’s go one step further and handle adding content and tokens to the story, as per our introduction.
Adding Tokens
For a contract to be able to interact with another contract, it needs to be aware of that other contract’s interface — the functions available to it. Since our TNS token has a fairly straightforward interface, we can include it as such in the contract of our DAO, above the contract StoryDao declaration and under our import statements:
contract LockableToken is Ownable {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool);
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool);
function transferFromAndCall(address _from, address _to, uint256 _value, bytes _data) public payable returns (bool);
function increaseLockedAmount(address _owner, uint256 _amount) public returns (uint256);
function decreaseLockedAmount(address _owner, uint256 _amount) public returns (uint256);
function getLockedAmount(address _owner) view public returns (uint256);
function getUnlockedAmount(address _owner) view public returns (uint256);
}
Notice that we don’t need to paste in the “meat” of the functions, but only their signatures (skeletons). This is all that’s needed to interact between contracts.
Now we can use these functions in the DAO contract. The plan is as follows:
launch the token (we already did this)
launch the DAO from the same address
send all tokens from the token-launcher to the DAO, then transfer ownership over the contract to the DAO itself
at this point the DAO owns all tokens and can sell them to people using the transfer function, or can reserve them for spending using the approve function (useful during votes), etc.
But how does the DAO know which address the token is deployed on? We tell it.
First, we add a new variable at the top of the DAO contract:
LockableToken public token;
Then, we add some functions:
constructor(address _token) public {
require(_token != address(0), “Token address cannot be null-address”);
token = LockableToken(_token);
}
The constructor is the function which gets called automatically when a contract is deployed. It’s useful for initializing values like linked contracts, default values, etc. In our case, we’ll use it to consume and save the address of the TNS token. The require check is there to make sure the token’s address is valid.
While we’re at it, let’s add a function that lets users check how many tokens remain for sale in the DAO, and the ability to change to another token should something go wrong and such a change be required. This change deserves an event, too, so let’s add that in as well.
event TokenAddressChange(address token);
function daoTokenBalance() public view returns (uint256) {
return token.balanceOf(address(this));
}
function changeTokenAddress(address _token) onlyOwner public {
require(_token != address(0), “Token address cannot be null-address”);
token = LockableToken(_token);
emit TokenAddressChange(_token);
}
The first function is set to view because it doesn’t change the state of the blockchain; it doesn’t alter any values. This means it’s a free, read-only function call to the blockchain: it doesn’t need a paid transaction. It also returns the balance of tokens as a number, so this needs to be declared on the function’s signature with returns (uint256). The token has a balanceOf function (see the interface we pasted in above) and it accepts one parameter — the address whose balance to check. We’re checking our (this) DAO’s balance, so “this”, and we turn “this” into an address with address().
The token address changing function allows the owner (admin) to change the token contract. It’s identical to the logic of the constructor.
Let’s see how we can let people buy the tokens now.
Buying Tokens
As per the previous part of the series, users can buy tokens by:
Using the fallback function if already whitelisted. In other words, just sending ether to the DAO contract.
Using the whitelistAddress function by sending more than the fee required for whitelisting.
Calling the buyTokens function directly.
There is a caveat, however. When someone calls the buyTokens function from the outside, we want it to fail if there aren’t enough tokens in the DAO to sell. But when someone buys tokens via the whitelist function by sending in too much in the first whitelisting attempt, we don’t want it to fail, because then the whitelisting process will get canceled as everything fails at once. Transactions in Ethereum are atomic: either everything has to succeed, or nothing. So we’ll make two buyTokens functions.
// This goes at the top of the contract with other properties
uint256 public tokenToWeiRatio = 10000;
function buyTokensThrow(address _buyer, uint256 _wei) external {
require(whitelist[_buyer], “Candidate must be whitelisted.”);
require(!blacklist[_buyer], “Candidate must not be blacklisted.”);
uint256 tokens = _wei * tokenToWeiRatio;
require(daoTokenBalance() >= tokens, “DAO must have enough tokens for sale”);
token.transfer(_buyer, tokens);
}
function buyTokensInternal(address _buyer, uint256 _wei) internal {
require(!blacklist[_buyer], “Candidate must not be blacklisted.”);
uint256 tokens = _wei * tokenToWeiRatio;
if (daoTokenBalance() < tokens) {
msg.sender.transfer(_wei);
} else {
token.transfer(_buyer, tokens);
}
}
So, 100 million TNS tokens exist. If we set a price of 10000 tokens per one ether, that comes down to around 4–5 cents per token, which is acceptable.
The functions do some calculations after doing sanity checks against banned users and other factors, and immediately send the tokens out to the buyer, who can start using them as they see fit — either for voting, or for selling on exchanges. If there’s fewer tokens in the DAO than the buyer is trying to buy, the buyer is refunded.
The part token.transfer(_buyer, tokens) is us using the TNS token contract to initiate a transfer from the current location (the DAO) to the destination _buyer for amount tokens.
Now that we know people can get their hands on the tokens, let’s see if we can implement submissions.
The post Ethereum DApps: Cross-contract Communication & Token Selling appeared first on SitePoint.
Original Source: https://www.sitepoint.com/building-ethereum-dapps-whitelisting-testing-story-dao/
In part 3 of this tutorial series on building DApps with Ethereum, we built and deployed our token to the Ethereum testnet Rinkeby. In this part, we’ll start writing the Story DAO code.
We’ll use the conditions laid out in the intro post to guide us.
Contract Outline
Let’s create a new contract, StoryDao.sol, with this skeleton:
pragma solidity ^0.4.24;
import “../node_modules/openzeppelin-solidity/contracts/math/SafeMath.sol”;
import “../node_modules/openzeppelin-solidity/contracts/ownership/Ownable.sol”;
contract StoryDao is Ownable {
using SafeMath for uint256;
mapping(address => bool) whitelist;
uint256 public whitelistedNumber = 0;
mapping(address => bool) blacklist;
event Whitelisted(address addr, bool status);
event Blacklisted(address addr, bool status);
uint256 public daofee = 100; // hundredths of a percent, i.e. 100 is 1%
uint256 public whitelistfee = 10000000000000000; // in Wei, this is 0.01 ether
event SubmissionCommissionChanged(uint256 newFee);
event WhitelistFeeChanged(uint256 newFee);
uint256 public durationDays = 21; // duration of story’s chapter in days
uint256 public durationSubmissions = 1000; // duration of story’s chapter in entries
function changedaofee(uint256 _fee) onlyOwner external {
require(_fee < daofee, “New fee must be lower than old fee.”);
daofee = _fee;
emit SubmissionCommissionChanged(_fee);
}
function changewhitelistfee(uint256 _fee) onlyOwner external {
require(_fee < whitelistfee, “New fee must be lower than old fee.”);
whitelistfee = _fee;
emit WhitelistFeeChanged(_fee);
}
function lowerSubmissionFee(uint256 _fee) onlyOwner external {
require(_fee < submissionZeroFee, “New fee must be lower than old fee.”);
submissionZeroFee = _fee;
emit SubmissionFeeChanged(_fee);
}
function changeDurationDays(uint256 _days) onlyOwner external {
require(_days >= 1);
durationDays = _days;
}
function changeDurationSubmissions(uint256 _subs) onlyOwner external {
require(_subs > 99);
durationSubmissions = _subs;
}
}
We’re importing SafeMath to have safe calculations again, but this time we’re also using Zeppelin’s Ownable contract, which lets someone “own” the story and execute certain admin-only functions. Simply saying that our StoryDao is Ownable is enough; feel free to inspect the contract to see how it works.
We also use the onlyOwner modifier from this contract. Function modifiers are basically extensions, plugins for functions. The onlyOwner modifier looks like this:
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
When onlyOwner is added to a function, then that function’s body is pasted into the part where the _; part is, and everything before it executes first. So by using this modifier, the function automatically checks if the message sender is also the owner of the contract and then continues as usual if so. If not, it crashes.
By using the onlyOwner modifier on the functions that change the fees and other parameters of our story DAO, we make sure that only the admin can do these changes.
The post Building Ethereum DApps: Whitelisting & Testing a Story DAO appeared first on SitePoint.
Original Source: http://feedproxy.google.com/~r/Designrfix/~3/NDhN2b4t5f8/tips-to-design-a-good-logo-for-a-client-or-yourself
Before entering your field of choice, you must understand that a good logo reflects the values of the brand by using forms, colors, and typographies. Its objective is to inspire confidence and recognition of your brand and help the company to stand out from the competition. When it comes to logo design, you get out of […]
The post Tips to Design a Good Logo for A Client or Yourself appeared first on designrfix.com.
Original Source: https://www.hongkiat.com/blog/50-most-beautiful-blogger-templates/
An updated list of beautiful yet advanced Blogger (Blogspot) templates free to download.
The post 50 Most Beautiful Blogger Templates to Download (2018) appeared first on Hongkiat.
Visit hongkiat.com for full content.
Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/3whUD8CCERI/google-chrome-extensions-21410570
Chrome's DevTools are great, but it's possible to add even more exciting features to your internet browser to make web design and development easier. Here are 29 of our favourite Chrome extensions for web designers and developers.
01. Sizzy
An easy way to test your site across multiple viewports
Responsive web design's a given these days, and it you want a straightforward way to check your designs across multiple viewports, Sizzy's worth a look. It'll show you an interactive view of your page rendered on a number of different device screen sizes, and you can also show and hide a simulated device keyboard, and switch between portrait and landscape modes.
02. Site Palette
If a colour scheme takes your fancy, Site Palette will help you borrow it
The next time you see a site that makes great use of colour, here's a simple way to take advantage of it. Site Palette extracts the main colours from a website and generates a shareable palette that you can easily show to collaborators. You can also download a Sketch template, and there's Adobe Swatch support, too.
03. Checkbot
Sort out all those broken links and get a free SEO boost
Making sure that all the links on your site actually work is an instant usability win and it's a good way to improve your SEO, too. Checkbot is a Chrome extension that checks for broken links, duplicate titles, redirect chains, invalid HTML/JS/CSS and more, so you can quickly audit your site for bad links and get them fixed.
04. Toby
Turn all those unruly tabs into useful collections of bookmarks
It is a truth universally acknowledged that by the time you've had Chrome open for a couple of hours it'll be a confusing nest of tabs the width of your little finger. Toby's a great way to tame them; with it you can organise all those tabs into collections of links as an alternative to loads of individual bookmarks, making them much easier to manage.
05. DomFlags
A new way to work with DevTools
Radically speed up the processes of styling elements with DomFlags, a truly great extension that lets you create keyboard shortcuts for DOM elements. It's like having bookmarks for navigating the DOM; this will change the way you work with DevTools.
06. Highly Highlighter
Highly, a new way to participate in industry conversation
Here's an interesting way to bring people into a discussion: Highly lets you share highlights from articles on the web, so you can draw attention to the most significant bits of writing.
07. Booom
Get a better Dribbble experience with Booom
Booom makes Dribbble better by showing larger shots in lists; putting Like and Add to Bucket buttons in lists; making GIFs autoplay and bringing infinite scroll.
08. CSS-Shack
This Chrome extension enables you to create layer styles and export them into a CSS file
This powerful Chrome extension enables you to create designs then export them into a CSS file for use on your site. It supports layers and contains a plethora of the tools that you're used to from your regular photo editor.
09. Marmoset
With Marmoset you can create gorgeous code snapshots within seconds
This brilliant extension will take your code and output snapshots for your demos and mockups. You can also add themes and effects to create images for promo and your online portfolio.
10. iMacros for Chrome
iMacros Chrome extension enables you to record actions and save them
As a web developer, you may be required to test your webpages. Repeating the same actions over and over again can be a tiresome process. iMacros is a handy Chrome extension that lets you record your actions and save them so you only need to do them once. After that you can test your pages over and over again, repeating the action with a click of a button. It saves valuable time, freeing up your time so you can concentrate on more pressing matters.
Next: 10 more Chrome extensions
11. Window Resizer
This Chrome extension re-sizes the browser window in order to emulate various resolutions
This Chrome extension is a useful tool that does exactly as it says on the tin – resizes your browser window to help you with your responsive website designs. Choose from a list of popular monitor dimensions or add custom sizes and resolutions for increased accuracy.
12. Project Naptha
With Naptha you can highlight, copy, edit, and translate text from any image on the web
If you ever find yourself working from a mockup image with embedded text, Project Naptha could save you a world of mild irritation. Thanks to some smart OCR trickery it enables you to highlight, copy and paste text from any image; it can even translate it for you.
13. WhatFont
What font are they using? The WhatFont Chrome extension can tell you!
A very useful Google Chrome extension, WhatFont allows developers and designers to identify the fonts being used on a webpage. So, if you stumble upon a fancy-looking web font that you want to use in one of your future projects, just hover over it and find out instantly which font it is.
14. Web Developer
The Web Developer Chrome extension provides a range of useful dev tools
As a web developer, you might ask yourself how you have lived without this extension. It adds a toolbar button to Chrome with a plethora of useful web developer tools. It's the official port of the Web Developer extension for Firefox.
15. Web Developer Checklist
Fix issues quickly with this handy Chrome extension
This tool allows you check if all of your webpages are following best practice when it comes to SEO, usability, accessibility and performance (page speed). So if, for example, you don't have an H1 tag on a webpage or if a webpage is missing its meta title or meta description, it will notify you so that you can fix the issue quickly. If you click the 'more info and help' link at the bottom of the extension, you will find a more in-depth checklist.
16. DevTools Autosave
Automatically save any changes to a page’s CSS and JS to its source file
A true gem for all web developers out there, DevTools AutoSave allows you to automatically save any changes that you make to a webpage's CSS and JS via the Chrome Dev Tools environment to its source file. It's easy to set up and use and it will save you lots of time and stress.
17. Instant Wireframe
View live webpages with a wireframe overlay
Turn any webpage into a wireframe with just one click. This Google Chrome extension helps web developers and designers view webpages, whether local or live on the web, with a wireframe overlay.
18. ColorZilla
With ColorZilla you can get a colour reading from any point in your browser
The ColorZilla Chrome extension is an advanced eyedropper, colour picker, gradient generator and useful colour tool that will help you in your design – right there in your browser window.
19. Streak CRM for Gmail
Turn an email conversation into a trackable, assignable ticket
Streak is the ultimate tool for managing CRM and support emails within Gmail. It allows you to turn a single email or an entire conversation into a trackable, assignable, organised ticket that you can manage yourself or share with others.
20. Search Stackoverflow
Get your questions answered quickly with this must-have extension
If you're a web developer then you've probably heard about Stack Overflow, the go-to place for any development related issues. If not, then you definitely need to check it out. The community is thriving and it covers a wide range of topics from C# and Java to PHP and jQuery. This fantastic extension adds a search box directly into your browser, allowing you to search the vast resources of Stack Overflow.
Next: more Chrome extensions
21. PerfectPixel
This extension helps you ensure your site matches the design pixel for pixel
Designers hate it when their stunning design doesn't match up perfectly when it's coded. Perfect Pixel really is the perfect extension for web developers who are striving to develop sites that are accurate representations of designs. This easy-to-use extension enables you to put a semi-transparent image overlay over the top of your webpage and perform a per pixel comparison between them to ensure it is 100% accurate.
22. Code Cola
Edit your webpages’ CSS on the spot
Not only does this tool allow you to view the source code of what you've been working on, but it also functions as a CSS editor. This means you can edit your webpages' CSS style on the spot and see the changes instantly.
23. IE tab
Test webpages with different versions of IE
One of the most popular and useful IE emulators available on the web, IE tab enables web developers to test webpages with different versions of IE directly in their Chrome browser.
24. PicMonkey
Grab every image from a webpage with a click of a button
This is an easy-to-use free online photo editor that allows you to edit webpage images and screenshots. But that's not what makes it so good. PicMonkey also lets you grab every image and a screenshot of the entire page with a click of a button. Once you select an image you can edit it in any way you wish, from applying effects to changing exposure.
25. Chrome Daltonize
Create images more suitable for viewing by those with Colour Vision Deficiency
Colour Vision Deficiency (CVD) or colour blindness affects millions of people across the globe. This ingenious extension uses Daltonization, a technique that allows the creation of images more suitable for viewing by those with CVD. This fantastic extension can be used to simulate how images appear to people with CVD and to help you design a more accessible web app.
26. Check My Links
Check My Links crawls through your webpage and looks for broken links
Finished building a site? Ah, but have you been through and checked all the links? No matter how careful you are, it's inevitable that you'll have overlooked one or two, and checking them all is a tedious chore. Unless…. With the Check My Links extension you can simply put it to work and it'll comb through all the links on any page, highlighting valid ones in green and broken ones in red.
27. Flickr Tab
Smarten up your Chome tabs with beautiful Flickr images
Are you tired of your Chrome tabs looking dull when you open a new one? The answer to your prayers has arrived in the form of Flickr Tab. It's a simple little Extension that displays a popular Fickr photograph each time you open up a window. Click the photo to view it in Flickr, or click the username to see more photos from the photographer.
28. Google Art Project
Make each new Chrome tab an adventure in art and discovery with the Google Art Project
Similar to Flickr Tab's glossy photos, Google's Art Project extension treats you to a high-res masterpiece from the likes of van Gogh and Monet in each new tab you open. If an image sparks your interest, click on it to go to the Google Cultural Institute website, which is full of information about the work and its creator.
29. Data Saver
Save cash when viewing designs on your mobile with Google’s compression based Data Saver
So, your latest bill from your mobile provider was rather toe curling? Don't panic. You need Data Saver, from Google. The extension does what it says on the tin: it reduces the amount of data used when browsing the web. When enabled, Chrome will use Google servers to compress pages before you download them. There's only one caveat: SSL and incognito pages won't be included.
Read more:
13 best pieces of user testing software30 web design tools to speed up your workflow23 steps to the perfect website layout
Original Source: http://feedproxy.google.com/~r/Designrfix/~3/R12VbSw7AsM/ultimate-front-end-development-bundle
So you want to become a web developer? Well, you made the right choice. As we progress towards a more tech-filled future, the demand for web developers is increasing. Companies are upping the salary to ensure that they hire the best talent out there. The good news is that you don’t need a degree to […]
The post 96% Off: Get The Ultimate Front End Development Bundle for $39 appeared first on designrfix.com.
Original Source: http://feedproxy.google.com/~r/abduzeedo/~3/6F2YKAJcEfw/sonikpass-awesome-brand-identity-and-web-design
Sonikpass Awesome Brand Identity and Web Design
abduzeedo
Jul 23, 2018
Rolf Jensen shared an incredible brand identity and web design project on his Behance profile. It is for Sonikpass, a San Fransisco based startup company creating an incorruptible digital version of you at the moment you want to conduct a digital transaction of any kind from logging into a secure digital access point to digitally unlocking the door to your home.
This post features some of the key visual features made for the branding and website in early 2018. Including a concept called redacted identity, emphasizing the core messaging of their product, celebrated in WebGL.
Rolf is an independent design director based in New York. He has an extensive portfolio including incredible projects for Disney, Sony, Adobe and many others. I especially love the God of War project, maybe because I am a fan of the game. For more information make sure to check out http://rolfjensen.no/
Web design
brand identity
Original Source: http://feedproxy.google.com/~r/CreativeBloq/~3/I8ejKl528Dk/will-brexit-wreck-the-vfx-industry
Having sat in screening rooms at ILM and Digital Domain for well over 18 years, I've heard my share of comments from big-name film directors regarding their review of shots for their films.
What will Brexit mean for the British VFX and CG industry?
The comment we were always hoping to hear was 'Final'. When the director said that magic word, a thunderous cheer was often heard from the men and women that had toiled for countless hours over that five or so seconds of film. But, when the team felt that the shot should be 'Finaled' and the director said 'CBB' (Could Be Better), we knew we were in for the long haul, because oftentimes the director had no idea what he or she was actually looking for.
Brexit could have some very serious consequences and implications for the visual effects industry, both in the UK and the rest of the world. But before we look at some of the issues regarding Brexit and the VFX industry, let's get a clear picture of the business of VFX.
What drives the industry
Let's be clear, Hollywood studios are looking for the best visual effects that will be delivered on time for the lowest price. A major blockbuster movie must be released on time. There's countless hours of planning and strategy by dozens of marketing execs, having reviewed all other studios' movies and their release dates to determine their film's date and overall marketing plan.
And generally speaking, they are pretty spot on with their date (except of course Titanic, which missed its July release and was finally released mid-December, catapulting its box office to dizzying heights, but that's another story). So, delivery is critical, and that is why generally speaking, the VFX studios that are of significant size and have a history of hitting outrageous schedules, get the work.
Of course, the studios want the very best quality, except when that quality costs too much. For example, when I was at the helm of ILM, I had a rather heated conversation with the president of Columbia Pictures regarding Air Force One. Arguing my case that the VFX looked horrible, the Columbia Exec asked me what ILM would have charged to do the VFX, and I gave him a number. He laughed and said, "Your price is $1.5 million higher than what we paid, are you telling me that we would have seen considerably more box office if the VFX were better?" He had a point.
Where Disney decides to spends its money has a huge impact on the industry
So, quality is important… but price is much more important. I learned my lesson. That's why I was sure that like most manufacturing, the manufacturing of VFX would move off shore to lower-cost environments, where wages were considerably less. I'd seen it happen in animation only a decade or two before. Animation was generally produced in the US by studios like Hanna-Barbera and Disney. But as prices rose due to increased labour costs, much of the animation moved to Korea and the Far East. I assumed, incorrectly so, that much of the VFX work would wind up in China and India.
But then came tax subsidies and rebates from English-speaking countries like Canada, Australia, New Zealand and the UK. And while the labour costs were higher than, say, India, the rebates, the ease of communication and the careful strategic coming together of the likes of Sohonet, gave the US studios everything that they wanted… a great price due to government sponsorship, English-speaking contractors and high-quality VFX due to the enormous influx of talent from around the world. London (and Vancouver) became the nexus for VFX.
Brexit: the pluses
Which currency will prevail post-Brexit?
Never forget, it's show business and as such, the studios and producers are always driven by price. There are two advantages that I see regarding VFX and Brexit. The pound to dollar pricing becomes quite attractive to US studios as the pound falls.
While I'm no economist, there have been several folks who have predicted that the pound will continue to fall against the dollar. The other opportunity is that the UK will no longer be bound by the rules of the EU, and as such, might make the subsidies and tax rebates even more attractive.
Brexit: the minuses
While the studios are driven by price, they are even more concerned about delivery. They are scared to death that they will miss their release date. Having done some research, the VFX workforce in London is approaching 50 per cent that are non-UK citizens, and 40 per cent of the current workforce are comprised of EU nationals.
While Brexit is not yet fully defined, it seems that it will force EU nationals to obtain the necessary work permits, which might prove very difficult, or not depending on the process – the proposed system announced recently suggests this process should be fairly straightforward. If it isn't, the result could be that London VFX studios would lose close to 50 per cent of its trained workforce. That could be disastrous.
With a diminished talent base, London will not be able to handle the big shows, and as such will bring great concern to the studios regarding the London facilities' ability to deliver the work on time.
The possible
Will EU workers be able to stay once the UK has Brexit-ed?
If the London-based VFX studios' management is able to petition the UK government to allow their EU employees to remain in the UK, or if the proposed process for EU residents to seek settled status is put in place, then all will be well. However, if that doesn't happen, well, the proverbial will hit the fan.
The US studios will look for alternative ways to address their VFX needs. One possibility is that the London-based facilities open VFX operations in other countries, like France or Germany. We've seen that this is already happening. Unfortunately, opening up a new facility will take a great deal of cash, which, given the current margins in the VFX industry, means the parent company will take yet another financial hit.
Additionally, all the EU employees presently working at the London facilities will have to, once again, uproot their lives and move (which will also cost the London-based facilities more money). So, as you can see, this is not a pretty picture for the facilities or the workers.
There have been talks about setting up hub/spoke-based operations. That is, the hub remains in London but various tasks such as rigging, match moves, modelling and compositing take place in distant locations. While seemingly attractive, this idea creates a bunch of issues. Security, proximity, governmental tax issues and subsidies now become a problem not only for the facility, but for the client too.
Remembering my time back in various VFX screening rooms, I kept my fingers crossed every time my teams would screen their shots for the director, hoping for that magic word… Final.
Unfortunately, Brexit looks like a CBB at best, or maybe even a famous Jim Cameron statement when viewing a shot that he didn't think was up to snuff, an 'NFG' (No Fucking Good).
This article was originally published in issue 235 of 3D World, the world's best-selling magazine for CG artists. Buy issue 235 here or subscribe to 3D World here.
Related articles:
Savage Brexit stamps are the best of BritishThe designer's guide to BrexitHow the web industry is coping in uncertain times
