Archive for category: Random Stories

Original Source: https://www.sitepoint.com/getting-started-react-beginners-guide/

In this guide, I’ll show you the fundamental concepts of React by taking you through a practical, step-by-step tutorial on how to create a simple Message App using React. I’ll assume you have no previous knowledge of React. However, you’ll need at least to be familiar with modern JavaScript and NodeJS.

React is a remarkable JavaScript library that’s taken the development community by storm. In a nutshell, it’s made it easier for developers to build interactive user interfaces for web, mobile and desktop platforms. One of its best features is its freedom from the problematic bugs inherent in MVC frameworks, where inconsistent views is a recurring problem for big projects. Today, thousands of companies worldwide are using React, including big names such as Netflix and AirBnB. React has become immensely popular, such that a number of apps have been ported to React — including WhatsApp, Instagram and Dropbox.

Prerequisites

As mentioned, you need some experience in the following areas:

functional JavaScript
object-oriented JavaScript
ES6 JavaScript Syntax

On your machine, you’ll need:

a NodeJS environment
a Yarn setup (optional)

If you’d like to take a look first at the completed project that’s been used in this guide, you can access it via GitHub.

[affiliate-section title=”Recommended Courses”][affiliate-card title=”The Best Way to Learn React for Beginners” affiliatename=”Wes Bos” text=”A step-by-step training course to get you building real world React.js + Firebase apps and website components in a couple of afternoons. Use coupon code ‘SITEPOINT’ at checkout to get 25% off.” url=”https://ReactForBeginners.com/friend/SITEPOINT” imageurl=”https://dab1nmslvvntp.cloudfront.net/wp-content/uploads/2017/07/1501203893wesbos.jpg”][/affiliate-section]

What is React?

React is a JavaScript library for building UI components. Unlike more complete frameworks such as Angular or Vue, React deals only with the view layer. Hence, you’ll need additional libraries to handle things such as data flow, routing, authentication etc. In this guide, we’ll focus on what React can do.

Building a React project involves creating one or more React components that can interact with each other. A React component is simply a JavaScript class that requires the render function to be declared. The render function simply outputs HTML code, which is implemented using either JSX or JavaScript code. A React component may also require additional functions for handling data, actions and lifecyle events.

React components can further be categorized into containers/stateful components and stateless components. A stateless component’s work is simply to display data that it receives from its parent React component. It can also receive events and inputs, which it passes up to its parent to handle. A React container or stateful component does the work of rendering one or more child components. It fetches data from external sources and feeds it to its child components. It also receives inputs and events from them in order to initiate actions.

Understanding the React DOM

Before we get to coding, you need to be aware that React uses a Virtual DOM to handle page rendering. If you’re familiar with jQuery, you know that it can directly manipulate a web page via the HTML DOM. In a lot of use cases, this direct interaction poses little to no problems. However, for certain cases, such as the running of a highly interactive, real-time web application, performance often takes a huge hit.

To counter this, the concept of the Virtual DOM was invented, and is currently being applied by many modern UI frameworks including React. Unlike the HTML DOM, the Virtual DOM is much easier to manipulate, and is capable of handling numerous operations in milliseconds without affecting page performance. React periodically compares the Virtual DOM and the HTML DOM. It then computes a diff, which it applies to the HTML DOM to make it match the Virtual DOM. This way, React does its best to ensure your application is rendered at a consistent 60 frames per second, meaning that users experience little or no lag.

Enough chitchat! Let’s get our hands dirty …

Start a Blank React Project

As per the prerequisites, I assume you already have a NodeJS environment setup. Let’s first install or update npm to the latest version.

$ npm i -g npm

Next, we’re going to install a tool, Create React App, that will allow us to create our first React project:

$ npm i -g create-react-app

Navigate to your project’s root directory and create a new React project using the tool we just installed:

$ create-react-app message-app

…
Success! Created message-app at /home/mike/Projects/github/message-app
Inside that directory, you can run several commands:

yarn start
Starts the development server.

yarn build
Bundles the app into static files for production.

yarn test
Starts the test runner.

yarn eject
Removes this tool and copies build dependencies, configuration files
and scripts into the app directory. If you do this, you can’t go back!

We suggest that you begin by typing:

cd message-app
yarn start

Happy hacking!

Depending on the speed of your internet connection, this might take a while to complete if this is your first time running the create-react-app command. A bunch of packages gets installed along the way, which are needed to set up a convenient development environment — including a web server, compiler and testing tools.

Navigate to the newly created message-app folder and open the package.json file.

{
“name”: “message-app”,
“version”: “0.1.0”,
“private”: true,
“dependencies”: {
“react”: “^15.6.1”,
“react-dom”: “^15.6.1”,
“react-scripts”: “1.0.12”
},
“scripts”: {
“start”: “react-scripts start”,
“build”: “react-scripts build”,
“test”: “react-scripts test –env=jsdom”,
“eject”: “react-scripts eject”
}
}

Surprise! You expected to see a list of all those packages listed as dependencies, didn’t you? Create React App is an amazing tool that works behind the scenes. It creates a clear separation between your actual code and the development environment. You don’t need to manually install Webpack to configure your project. Create React App has already done it for you, using the most common options.

Let’s do a quick test run to ensure our new project has no errors:

$ yarn start

Starting development server…
Compiled successfully!

You can now view message-app in the browser.

Local: http://localhost:3000/
On Your Network: http://10.0.2.15:3000/

Note that the development build is not optimized.
To create a production build, use yarn build.

If you don’t have Yarn, just substitute with npm like this: npm start. For the rest of the article, use npm in place of yarn if you haven’t installed it.

Your default browser should launch automatically, and you should get a screen like this:

One thing to note is that Create React App supports hot reloading. This means any changes we make on the code will cause the browser to automatically refresh. For now, let’s first stop the development server by pressing Ctrl + C. This step isn’t necessary, I’m just showing you how to kill the development server. Once the server has stopped, delete everything in the src folder. We’ll create all the code from scratch so that you can understand everything inside the src folder.

Introducing JSX Syntax

Inside the src folder, create an index.js file and place the following code in it:

import React from ‘react’;
import ReactDOM from ‘react-dom’;

ReactDOM.render(<h1>Hello World</h1>, document.getElementById(‘root’));

Start the development server again using yarn start or npm start. Your browser should display the following content:

This is the most basic “Hello World” React example. The index.js file is the root of your project where React components will be rendered. Let me explain how the code works:

Line 1: React package is imported to handle JSX processing
Line 2: ReactDOM package is imported to render React components.
Line 4: Call to render function

<h1>Hello World</h1>: a JSX element
document.getElementById(‘root’): HTML container

The HTML container is located in public/index.html file. On line 28, you should see <div id=”root”></div>. This is known as the root DOM because everything inside it will be managed by the React DOM.

JSX (JavaScript XML) is a syntax expression that allows JavaScript to use tags such as <div>, <h1>, <p>, <form>, and <a>. It does look a lot like HTML, but there are some key differences. For example, you can’t use a class attribute, since it’s a JavaScript keyword. Instead, className is used in its place. Also, events such as onclick are spelled onClick in JSX. Let’s now modify our Hello World code:

const element = &lt;div&gt;Hello World&lt;/div&gt;;

ReactDOM.render(element, document.getElementById(‘root’));

I’ve moved out the JSX code into a variable named element. I’ve also replaced the h1 tags with div. For JSX to work, you need to wrap your elements inside a single parent tag. This is necessary for JSX to work. Take a look at the following example:

const element = &lt;span&gt;Hello,&lt;/span&gt; &lt;span&gt;Jane&lt;/span;

The above code won’t work. You’ll get a syntax error telling you must enclose adjacent JSX elements in an enclosing tag. Basically, this is how you should enclose your elements:

const element = &lt;div&gt;
&lt;span&gt;Hello, &lt;/span&gt;
&lt;span&gt;Jane&lt;/span&gt;
&lt;/div&gt;;

How about evaluating JavaScript expressions in JSX? Simple, just use curly braces like this:

const name = “Jane”;
const element = &lt;p&gt;Hello, {name}&lt;/p&gt;

… or like this:

const user = {
firstName: “Jane”,
lastName: “Doe”
}
const element = &lt;p&gt;Hello, {user.firstName} {user.lastName}&lt;/p&gt;

Update your code and confirm that the browser is displaying “Hello, Jane Doe”. Try out other examples such as { 5 + 2 }. Now that you’ve got the basics of working with JSX, let’s go ahead and create a React component.

Continue reading %Getting Started with React: A Beginner’s Guide%

Original Source: https://www.smashingmagazine.com/2017/09/ux-scale-design-free-webinars-2017/

Design doesn’t scale as cleanly as engineering. It’s not enough that each element and page is consistent with each other — the much bigger challenge lies in keeping the sum of the parts intact, too. And accomplishing that with a lot of designers involved in the same project.

If you’re working in a growing startup or a large corporation, you probably know the issues that come with this: The big-picture falls from view easily as everyone is focusing on the details they are responsible for, and conceptions about the vision of the design might be interpreted differently, too. What we need is a set of best practices to remove this friction and make the process smoother. A strategy to scale design without hurting it.

The post UX At Scale 2017: Free Webinars To Get Scaling Design Right appeared first on Smashing Magazine.

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/MiqWTIlPpAk/7-essential-steps-build-successful-mobile-app

Mobile phones are ruling our modern age. We have witnessed many developments in the field of technology and one of the most notable growths that technology presented us is mobile technology. In the present day, it has become very tough for people to live even a single day without using their mobile phones. It is […]

The post 7 Essential Steps to Build a Successful Mobile App appeared first on designrfix.com.

Original Source: http://inspiredm.com/introduction-building-webapps-vue-js/

Inspired Magazine
Inspired Magazine – creativity & inspiration daily

There are so many JavaScript frameworks in existence these days, it can be difficult to keep track of them all, and certainly it’s unlikely that anyone will master them in entirety. What it means for most of us is that we’ll need to be selective about which development frameworks we’re going to invest time into learning.

In this article, we’ll take a quick look at Vue.js, so you can decide for yourself if it’s likely to suit the kind of projects you tend to work on, and whether it seems like a good fit for you.

What is Vue.js?

Although it’s conventionally not capitalized, “Vue” is really an acronym for Visual Understanding Environment. Its main purpose is to make it easier to develop web applications by reducing code complexity. It has a lot in common with React.js, but the current version of Vue renders faster then React, and seems to be more efficient.

Is Vue difficult to learn?

If you’re already an experienced coder, you shouldn’t have much difficulty getting started with Vue, but it wouldn’t be right to describe it as a beginner language. You need to have some experience with HTML, CSS, and JavaScript to build anything practical with it.

The learning curve with Vue is a little less steep than with React, and it’s a lot less steep than with Angular. So what can be accurately stated is that Vue is relatively easy to learn in comparison to other popular development frameworks.

How does Vue help to achieve objectives?

It varies a bit depending on what your objective actually is, but  in general, you bind code blocks to HTML divs. This methodology makes it easier to introduce interactivity and dynamic content than with regular HTML, CSS and JavaScript.

On the other hand, you can’t really do more in Vue than you could by using the more conventional ways.  Using Vue is simply a matter of making things easier for you in the development phase, but it doesn’t have much effect on the end result, apart from minor performance impact due to loading the framework code.

Another advantage of Vue is that it provides modularity, meaning you can re-use components you develop in multiple projects.

Does Vue have any cool tricks up its sleeve?

It certainly does, and the best of these is built-in transition effects, which allow you to take control of what would otherwise be very code-intensive CSS and JavaScript structures using just a line or two of code. This saves you time and effort when creating your applications.

Another useful feature is native rendering for specific device types such as Android and iOS, so you can fine tune your applications for the devices they’re running on without a lot of extra work.

Getting started

As stated earlier, Vue is easy to learn, but it’s not a beginner’s language. You still need to know your way around inside a code block. If you have knowledge of HTML, CSS and JavaScript, the easy way to get started is by looking at an official Vue demo project.

The problem is that like most frameworks, the documentation is very lazy, and mainly dedicated to convincing you to use it. Much less attention is given in the documentation to explaining how everything works or why you do things a certain way. Virtually every official framework example ever created leaves out vital information that you have to poke around for hours to discover. That’s a flaw shared by Vue’s documentation and examples as well.

To make it easier to understand what you really need to do to re-create this project, these are the required steps:

1. Add a script referencing vue.js

For speed optimization, it’s best to include this after all your page content, but just before the closing body tag in the HTML source. You may also have other page resources loading in this section also, and the order of loading priority determines which order you should insert each resource.

Here is an example of including vue.js from a CDN:

And here is an example of including vue.js from a directory on your own server:

Without this reference to vue.js, nothing related to Vue can happen.

2. Add the Vue components into your HTML body

That’s what’s going on with this code:

For now it doesn’t make a lot of sense, but the Vue part is the empty “demo-grid” element, plus the addition of a “v-directive” to the query input (in this case it is “v-model”, which is used for binding Vue code to form inputs).

3. If the project requires a component template, add this to the HTML body

This section of code is unusual because it looks like regular HTML inside a script tag, which will confuse most HTML editing software (notice the indicator colors are wrong in some places).

4. Add the Vue instance

This should be one of the last things to appear on the page, because it’s performing  a dynamic rendering task. This provides some optimization benefits over adding it earlier in the page.

Line 46 specifies that the browser should look for a component on the page called “demo-grid”, and line 47 specifies that “#grid-template” should be used as the template for the component (this is the template code added at step 3 from line 9 to line 30).
A block from line 48 to line 52 defines the properties of the component.
Lines 53 to 62 define a function for sorting the data in the table.
Lines 63 to 85 define a function for filtering data (from results in the search query).
Lines 86 to 90 define a function for capitalizing the words in a data set.
Lines 91 to 97 define the method for sorting data.

5. Add in the launch code before the closing script tag

If you completed steps 1 to 4 and opened the file in the browser, all you would see is the search box and nothing more.  That’s because everything required to build the table has been defined but not created. So in step 5, we add the code that actually creates the table that was defined by all the previous steps.

Line 100 creates a new Vue object.
Line 101 specifies which element to bind the action to.
Lines 102 to 111 provide the object data that will be bound to the element.

Testing

Having defined and created the requisite object, you are now ready to test the result.  Prepare to be underwhelmed, because this is what you should see in the browser:

What’s going on? Why is it so boring?  It’s because there’s no styling applied. If we use the default styling from the JSFiddle example, the table would look like this:

Typing anything in the search box (not case-sensitive) will filter the results accordingly:

Clicking on a column header will allow you to change the order of display. For example, clicking on the “Power” column header will change the results to be displayed in order of power level.

Improving and adapting

Another issue with framework examples is that they usually don’t include much information to help somebody unfamiliar with the codebase to figure out how to apply in the field what they see in the example. Vue does a magnificent job compared to Bootstrap (which is notoriously under-informative),  but still leaves plenty of unanswered questions.

Here are a few changes we might make to this application to change how it looks and what it does:

Style the table as a Bootstrap striped table
Change the number of columns
Change the data to something completely different

1. Adding Bootstrap

2. Wrapping the element in a Bootstrap table

3. Adjusting the root element to use the Bootstrap layout model

4. Restyling the arrows

5. Modifying the data

6. Testing

Unfiltered & unsorted

Sorted by Directive (ascending)

Sorted by Used For (ascending)

Filtered for “conditional”

Filtered for “conditional” & sorted by Directive (ascending)

Final thoughts

Hopefully what was evident from these examples was that we built two applications with very different looks and content from a common slice of code. With Vue it is very easy to re-use your code across multiple projects, and potentially enjoy considerable time savings.

header image courtesy of Aleksandar Savic

This post Introduction to Building WebApps in Vue.js was written by Inspired Mag Team and first appearedon Inspired Magazine.

Original Source: http://feedproxy.google.com/~r/Designrfix/~3/60IEKriMnwA/pay-microsoft-office-productivity-bundle

Microsoft Office is a set of desktop applications that provide simple and efficient ways to present, manage, and organize information. Employees in most companies are expected to know how to write a report in Microsoft Word, create a presentation in Powerpoint, and analyze data in Excel. Although these are the most widely used programs of […]

The post Pay What You Want: Microsoft Office Productivity Bundle appeared first on designrfix.com.