15+ Best Presentation Software Alternatives to PowerPoint (of 2017)

Whether you're a student, a business professional, or a member of an organization—the odds are good that at some point you'll be asked to make a presentation. You may even need to create a presentation for online viewing. Whatever the need...when the time comes for you to make a...

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by Web Desk via Digital Information World

6 Pro Tips from React Developers

We've teamed up with Open SourceCraft to bring you 6 Pro Tips from React Developers.
Tip 1: Use functional components
Tip 2: Keep your components small
Tip 3: Understand how to handle this

Continue reading %6 Pro Tips from React Developers%

by Gregg Pollack via SitePoint

React Lifecycle Reference Guide

This is a reference guide to help developers quickly figure out which lifecycle method will best fit a solution they're currently working on in React.

constructor(props)

The constructor for a React component is the first method that gets called. This is where you should initiate state. You should ensure you execute super(props) first. Otherwise, bugs will crop up.

constructor(props) {
  super(props);
  this.state = {
    count: props.initialCount
  };
}

componentWillMount()

This method is called just before component mounting and render method. Setting state here won't trigger a re-render. This method sounds like a nice place to set the component's initial state. However, React's official guidelines recommend using the constructor() instead.

componentWillMount() {
  // perform setState operations
}

render()

This is a mandatory method for all React components. It will be invoked when state changes, when the parent component causes it to re-render, or when component.forceUpdate() is called.

The render() method is where you put your JSX code. You can also return false or null if you don't want to render anything. You can read values from this.prop and this.state, but you can't call this.setState() (or call another function that does). You should also not directly interact with the DOM. Instead, use componentDidMount().

render() {
  const {message} = this.state;

  return(
    <div>
      h1>List of Messages</h1>
      <MessageView message={message} />
    </div>
  )
}

componentDidMount()

This method is invoked right after the component has been mounted and render() has been called. Once a component mounts, it means you have access to the actual DOM nodes. This is a good place for performing network requests such as an API call. If you set state here, a re-render will be triggered.

componentDidMount = () => {
  this.props.fetchContacts()
}

shouldComponentUpdate(nextProps, nextState)

This method is invoked just before render() whenever there are new props or state changes. The method should only return true or false. If you return false, this means the render function won't be called. However, do note that:

• this method isn't called in the initial rendering
• child components will still re-render if you return false
• future versions may not enforce this directive, but instead use it as a hint.

This method has access to nextProps and nextState, which gives you an opportunity to compare them with the current props/state and determine if a re-render is necessary. This is a good place to implement performance optimization code.

shouldComponentUpdate(nextProps, nextState) {
  // put performance optimization code here
  return true;
}

Continue reading %React Lifecycle Reference Guide%

by Michael Wanyoike via SitePoint

How to Create Viral Infographics Using PowerPoint or Keynote #infographic

Here's a simple 7-step formula for planning, publishing and promoting infographics that go viral. No design experience or expensive software required.

[ This is a content summary only. Visit our website http://ift.tt/1b4YgHQ for full links, other content, and more! ]

by Web Desk via Digital Information World

How to Pass Data Between Activities With Android Parcelable

An Introduction to JSX

When React was first introduced, one of the features that caught most people's attention (and drew the most criticism) was JSX. If you're learning React, or have ever seen any code examples, you probably did a double-take at the syntax. What is this strange amalgamation of HTML and JavaScript? Is this even real code?

Let's take a look at what JSX actually is, how it works, and why the heck we'd want to be mixing HTML and JS in the first place!

What is JSX?

Defined by the React Docs as an "extension to JavaScript" or “syntax sugar for calling React.createElement(component, props, ...children))”, JSX is what makes writing your React Components easy.

JSX is considered a domain-specific language (DSL), which can look very similar to a template language, such as Mustache, Thymeleaf, Razor, Twig, or others.

It doesn't render out to HTML directly, but instead renders to React Classes that are consumed by the Virtual DOM. Eventually, through the mysterious magic of the Virtual DOM, it will make its way to the page and be rendered out to HTML.

How Does it Work?

JSX is basically still just JavaScript with some extra functionality. With JSX, you can write code that looks very similar to HTML or XML, but you have the power of seamlessly mixing JavaScript methods and variables into your code. JSX is interpreted by a transpiler, such as Babel, and rendered to JavaScript code that the UI Framework (React, in this case) can understand.

Don't like JSX? That's cool. It's technically not required, and the React Docs actually include a section on using “React Without JSX”. Let me warn you right now, though, it's not pretty. Don't believe me? Take a look.

JSX:

class SitePoint extends Component {
  render() {
    return (
      <div>My name is <span>{this.props.myName}</span></div>
    )
  }
}

React Sans JSX:

class SitePoint extends Component {
  render() {
    return React.createElement(
      "div",
      null,
      "My name is",
      React.createElement(
        "span",
        null,
        this.props.myName
      )
    )
  }
}

Sure, looking at those small example pieces of code on that page you might be thinking, "Oh, that's not so bad, I could do that." But could you imagine writing an entire application like that?

The example is just two simple nested HTML elements, nothing fancy. Basically, just a nested Hello World. Trying to write your React application without JSX would be extremely time consuming and, if you're like most of us other developers out here working as characters in DevLand™, it will very likely quickly turn into a convoluted spaghetti code mess. Yuck!

Using frameworks and libraries and things like that are meant to make our lives easier, not harder. I'm sure we've all seen the overuse and abuse of libraries or frameworks in our careers, but using JSX with your React is definitely not one of those cases.

Continue reading %An Introduction to JSX%

by Matt Burnett via SitePoint

Pixelius

One Page portfolio for Spanish designer Emilio García featuring a "pixelated" theme. Neat touch with the progress bar (in the fixed header) as you scroll.

Full Review | Direct Link

by Rob Hope @robhope via One Page Love