Cool Keyboard Shortcuts Few People Know About [video]

We have become so addicted to the mouse, that we do not realize how much it disrupts our workflow. Every time you reach out for it, you’re losing a tiny bit of focus and time. And have you ever accidentally knocked something over while trying to get hold of your mouse? The keyboard on the other...

[ 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

11 Productivity Tools to Help Web Developers Beat Deadlines

It's a common scenario: you have a plan for how your day will go, and how much you'll get done, and you end up with an unfinished list, wondering where the day went.

This article presents a list of tools that help increase productivity in the workplace. I've grouped them into four categories: time management, checklists, scheduling and project management. Each tackles a particular type of productivity problem.

Time Tracking

If you don't "run the day", it will run you. One way to take control is to trace every minute of your productive activities. Sounds quite hard, but it really isn't with a little discipline and the right tools. Here are a few apps that can help you do just that …

TMetric Time Tracker

• Basic version: free
• Professional version: $4/user/m
• Business version: $6/user/month

TMetric is a simple but powerful, web-based app that can help you keep track of your work hours. It has an easy-on-the-eye interface. Simply add a task, how long it's supposed to last, and press Start to track it.

The app works on a simple hierarchy. Tasks come under Projects which come under Clients. Each of the categories can be tracked independently so that you know exactly how much time's being spent where.

The app can give you a quick snapshot of how you're spending your days through its Workday Timeline feature. You can also collaborate with other members on your team and watch how everyone's spending their time through Team View. The app generates detailed reports of time spent and money earned from each project. Business owners can set rates for different types of works and calculate salaries for their employees effortlessly.

TMetric makes it very easy to keep track of billable and non-billable time separately, so that you're on top of your expenses and revenue. You can use their tags feature to further organize tasks or projects.

Finally, the app can easily integrate with popular project management software such as Trello, Asana, Jira, Todoist and many more, allowing you to seamlessly use them as one complete solution.

ManicTime

• Basic version: free
• Professional version: $67/license/year

Unlike other web-based apps, ManicTime is a downloadable program that runs in the background, tracking everything you do. It can tell you which programs you opened, which files you worked on and the amount of time you spent on them.

The program allows you to tag periods of time, which makes it very easy to create time sheets. A great thing about ManicTime is that you don't need to log in to a website: click start, then click stop when a piece of work is finished, which can be quite hard to manage. An app that automatically tracks your actions is pretty cool!

Timely

• Essential version: $14/user/month
• Company version: $21/user/month
• Enterprise version: $49/user/month

Timely is a visually impressive app. Its kanban-like interface allows you to drag and drop blocks (with your tasks) into a calendar, giving you a complete snapshot of your day in an instant.

Reporting is one of the best features that Timely offers. You can check how you've spent time by the day, week or month. You can also compare the time you actually spent on a project against the time you thought you would take --- very useful, if you ask me!

Projects can be set up as billable or unbillable. (There are tasks that won't bring in money, even though they're important.) You can also assign an hourly rate to your projects, or set up a flat fee and track the time spent on them to see how much you made by the hour.

Finally, no visual application would be complete without color coding, and with Timely, you can assign any number of colors to rate your tasks.

Checklists

If you're fed up with post-its, journals or always having to carry around a small notebook, then a checklist app is what you need. These apps take remembering out of the task equation, so that you can focus on what you need to do right now. The following three checklist apps are, in my view, the best available right now …

Wunderlist

• Basic version: free
• Pro version: $4.99
• Business version: $4.99/user

Wunderlist is a well-known checklist app --- and well enough liked that Microsoft bought it for $200 million. Wunderlist is a simple, lightweight app that can help you quickly create to-do lists and follow up with them. The app offers limited recurring task support, and even permits collaboration with other people.

Wunderlist offers cross-platform support and can be accessed from any device. This is super important, as you never know where you might need to add that sudden task to your list. Like most checklist apps, Wunderlist offers periodic reminders, and also makes it very easy to track your tasks, while giving you a quick look at what tasks are overdue.

Todoist

• Basic version: Free
• Premium version: $29/year
• Business version: $29/user/year

The team at Todoist decided to create a checklist app designed along the lines of a typical email client interface, which makes Todoist seem instantly familiar the moment you open it. Its minimalist interface allows you to quickly add tasks and make changes without needing to jump through hoops.

Not only can you add tasks through the app, but also by sending an email through a browser plugin for Gmail, Thunderbird or Outlook. Like Wunderlist, Todoist is multi-platform and can work on any device.

Todoist has an awesome feature that allows you to add tasks by simply typing out regular sentences with dates like "Wednesday at 11 AM", or "every Friday at 4 PM".

This is the only checklist app I know of that gamifies productivity. You're awarded "Karma" points every time you finish a task, and you can accumulate Karma over time to see how well you're performing against your colleagues!

Remember the Milk

• Basic version: Free
• Pro version: $39.99/year

Don't let the mellow name fool you: this is one well-thought-out checklist app! Remember the Milk (or RTM, as it's popularly known) was one of the first checklist apps to hit the market, and has a lot going on under the hood.

First off, RTM has been using natural language task entry since its inception. You only need say something like "send mail to Tom at 9 AM on Wednesday" to add it to a to-do list.

The developers of RTM know that the real problem isn't adding tasks to a list as much as it is remembering to do them when the time comes. So, they've added every possible alert method. Push notifications on mobile, desktop, SMS, Skype, AIM, Google Hangout, Twitter --- you name it, it's there!

The Pro version comes with the full gamut of collaboration tools, including subtasks, smart tasks lists and tags.

Continue reading %11 Productivity Tools to Help Web Developers Beat Deadlines%

by Parth Misra via SitePoint

Writing Plugins in Go

Go couldn't load code dynamically prior to Go 1.8. I'm a big proponent of plugin-based systems, which in many cases require loading plugins dynamically. I even considered at some point writing a plugin package based on C integration.

I'm super excited that the Go designers added this capability to the language. In this tutorial, you'll learn why plugins are so important, what platforms are currently supported, and how to create, build, load and use plugins in your programs.   

The Rationale for Go Plugins

Go plugins can be used for many purposes. They let you break down your system into a generic engine that's easy to reason about and test, and a lot of plugins adhere to a strict interface with well-defined responsibilities. Plugins can be developed independently from the main program that uses them. 

The program can use different combinations of plugins and even multiple versions of the same plugin at the same time. The crisp boundaries between the main program and plugins promote the best practice of loose coupling and separation of concerns.

The "plugin" Package

The new "plugin" package introduced in Go 1.8 has a very narrow scope and interface. It provides the Open() function to load a shared library, which returns a Plugin object. The Plugin object has a Lookup() function that returns a Symbol (empty interface{}) hat can be type asserted to a function or variable exposed by the plugin. That's it.

Platform Support

The plugin package is supported only on Linux at this time. But there are ways, as you'll see, to play with plugins on any operating system.

Preparing a Docker-Based Environment

If you're developing on a Linux box then you just need to install Go 1.8 and you're good to go. But, if you're on Windows or macOS, you need a Linux VM or Docker container. To use it, you must first install Docker.

Once you have Docker installed, open a console Window and type: docker run -it -v ~/go:/go golang:1.8-wheezy bash

This command maps my local $GOPATH at ~/go to /go inside the container. That lets me edit the code using my favorite tools on the host and have it available inside the container for building and running in the Linux environment.

For more information on Docker, check out my "Docker From the Ground Up" series here on Envato Tuts+:

• Docker From the Ground Up: Understanding Images
• Docker From the Ground Up: Building Images
• Docker From the Ground Up: Working With Containers, Part 1
• Docker From the Ground Up: Working With Containers, Part 2

Creating a Go Plugin

A Go plugin looks like a regular package, and you can use it as a regular package too. It becomes a plugin only when you build it as a plugin. Here are a couple of plugins that implement a Sort() function that sorts a slice of integers. 

QuickSort Plugin

The first plugin implements a naive QuickSort algorithm. The implementation works on slices with unique elements or with duplicates. The return value is a pointer to a slice of integers. This is useful for sort functions that sort their elements in place because it allows returning without copying. 

In this case, I actually create multiple interim slices, so the effect is mostly wasted. I sacrifice performance for readability here since the goal is to demonstrate plugins and not implement a super efficient algorithm. The logic goes as follows:

• If there are zero items or one item, return the original slice (already sorted).
• Pick a random element as a peg.
• Add all the elements that are less than the peg to the below slice.
• Add all the elements that are greater than the peg to the above slice. 
• Add all the elements that are equal to the peg to the middle slice.

At this point, the middle slice is sorted because all its elements are equal (if there were duplicates of the peg, there will be multiple elements here). Now comes the recursive part. It sorts the below and above slices by calling Sort() again. When those calls return, all the slices will be sorted. Then, simply appending them results in a full sort of the original slice of items.

package main

import "math/rand"


func Sort(items []int) *[]int {
    if len(items) < 2 {
        return &items
    }

    peg := items[rand.Intn(len(items))]

    below := make([]int, 0, len(items))
    above := make([]int, 0, len(items))
    middle := make([]int, 0, len(items))

    for _, item := range items {
        switch {
        case item < peg:
            below = append(below, item)
        case item == peg:
            middle = append(middle, item)
        case item > peg:
            above = append(above, item)
        }
    }

    below = *Sort(below)
    above = *Sort(above)

    sorted := append(append(below, middle...), above...)
    return &sorted
}

BubbleSort Plugin

The second plugin implements the BubbleSort algorithm in a naive way. BubbleSort is often considered slow, but for a small number of elements and with some minor optimization it often beats more sophisticated algorithms like QuickSort. 

It is actually common to use a hybrid sort algorithm that starts with QuickSort, and when the recursion gets to small enough arrays the algorithm switches to BubbleSort. The bubble sort plugin implements a Sort() function with the same signature as the quick sort algorithm. The logic goes as follows:

• If there are zero items or one item, return the original slice (already sorted).
• Iterate over all the elements.
• In each iteration, iterate over the rest of the items.
• Swap the current item with any item that is greater.
• At the end of each iteration, the current item will be in its proper place.

package main


func Sort(items []int) *[]int {
    if len(items) < 2 {
        return &items
    }

    tmp := 0

    for i := 0; i < len(items); i++ {
        for j := 0; j < len(items)-1; j++ {
            if items[j] > items[j+1] {
                tmp = items[j]
                items[j] = items[j+1]
                items[j+1] = tmp
            }
        }
    }

    return &items
}

Building the Plugin

Now, we have two plugins we need to build to create a shareable library that can be loaded dynamically by our main program. The command to build is: go build -buildmode=plugin

Since we have multiple plugins, I placed each one in a separate directory under a shared "plugins" directory. Here is the directory layout of the plugins directory. In each plugin subdirectory, there is the source file "<algorithm>_plugin.go" and a little shell script "build.sh" to build the plugin. The final .so files go into the parent "plugins" directory:

$ tree plugins
plugins
├── bubble_sort
│   ├── bubble_sort_plugin.go
│   └── build.sh
├── bubble_sort_plugin.so
├── quick_sort
│   ├── build.sh
│   └── quick_sort_plugin.go
└── quick_sort_plugin.so

The reason the *.so files go into the plugins directory is that they can be discovered easily by the main program, as you'll see later. The actual build command in each "build.sh" script specifies that the output file should go into the parent directory. For example, for the bubble sort plugin it is:

go build -buildmode=plugin -o ../bubble_sort_plugin.so

Loading the Plugin

Loading the plugin requires knowledge of where to locate the target plugins (the *.so shared libraries). This can be done in various ways:

• passing command-line arguments
• setting an environment variable
• using a well-known directory
• using a configuration file

Another concern is if the main program knows the plugin names or if it discovers dynamically all the plugins in a certain directory. In the following example, the program expects that there will be a sub-directory called "plugins" under the current working directory, and it loads all the plugins it finds.

The call to the filepath.Glob("plugins/*.so") function returns all the files with the ".so" extension in the plugins sub-directory, and plugin.Open(filename) loads the plugin. If anything goes wrong, the program panics.

package main

import (
    "fmt"
    "plugin"
    "path/filepath"
)

func main() {
    all_plugins, err := filepath.Glob("plugins/*.so")
    if err != nil {
        panic(err)
    }

    for _, filename := range (all_plugins) {
        fmt.Println(filename)
        p, err := plugin.Open(filename)
        if err != nil {
            panic(err)
        }
    }
}

Using the Plugin in a Program

Locating and loading the plugin is only half the battle. The plugin object provides the Lookup() method that given a symbol name returns an interface. You need to type assert that interface into a concrete object (e.g. a function like Sort()). There is no way to discover what symbols are available. You just have to know their names and their type, so you can type assert properly. 

When the symbol is a function, you can invoke it like any other function after a successful type assert. The following example program demonstrates all these concepts. It dynamically loads all the available plugins without knowing which plugins are there except that they are in the "plugins" sub-directory. It follows by looking up the "Sort" symbol in each plugin and type asserting it into a function with the signature func([]int) *[]int. Then, for each plugin, it invokes the sort function with a slice of integers and prints the result.

package main

import (
    "fmt"
    "plugin"
    "path/filepath"
)

func main() {
    numbers := []int{5, 2, 7, 6, 1, 3, 4, 8}

    // The plugins (the *.so files) must be in a 'plugins' sub-directory
    all_plugins, err := filepath.Glob("plugins/*.so")
    if err != nil {
        panic(err)
    }

    for _, filename := range (all_plugins) {
        p, err := plugin.Open(filename)
        if err != nil {
            panic(err)
        }
        
        symbol, err := p.Lookup("Sort")
        if err != nil {
            panic(err)
        }

        sortFunc, ok = symbol.(func([]int) *[]int)
        if !ok {
            panic("Plugin has no 'Sort([]int) []int' function")
        }

        sorted := sortFunc(numbers)
        fmt.Println(filename, sorted)
    }
}

Output:

plugins/bubble_sort_plugin.so &[1 2 3 4 5 6 7 8]
plugins/quick_sort_plugin.so &[1 2 3 4 5 6 7 8]

Conclusion

The "plugin" package provides a great foundation for writing sophisticated Go programs that can dynamically load plugins as necessary. The programming interface is very simple and requires detailed knowledge of the using program on the plugin interface. 

It is possible to build a more advanced and user-friendly plugin framework on top of the "plugin" package. Hopefully, it will be ported to all the platforms soon. If you deploy your systems on Linux, consider using plugins to make your programs more flexible and extensible.

by Gigi Sayfan via Envato Tuts+ Code

What Happens in an Internet Minute in 2017? [infographic]

Just a month ago, it was revealed that Facebook has more than two billion active monthly users. That means that in any given month, more than 25% of Earth’s population logs in to their Facebook account at least once. The scale of the internet is so great, that it doesn’t make sense to look at the...

[ 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 Manage Blog Content With Trello

Do you need a better way to manage your blog content? Looking for a tool to outline your blogging workflow from beginning to end? In this article, you’ll discover how to effectively organize how you brainstorm, write, and publish your blog’s content with Trello. #1: Create a Trello Board for Your Blog Workflow Trello is [...]

This post How to Manage Blog Content With Trello first appeared on .
- Your Guide to the Social Media Jungle

by Marc Schenker via

How to use the popular selfie app FaceApp [video]

A popular new app called FaceApp is taking over your Facebook and Twitter feeds. Users can apply various filters to their faces to make them look different ages or different genders. It can also give you a smile that looks surprisingly realistic.

[ 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

Palette.js – Beautiful Palette Colors

Palette.js is a javascript library to add a beautiful palette colors to your project with a single line of code.

by via jQuery-Plugins.net RSS Feed