Software Dev.

4 Recommended Features for Employee Productivity Monitoring Software

admin — Mon, 21 Dec 2020 04:24:25 +0000

4 Recommended Features for Employee Productivity Monitoring Software admin Mon, 12/21/2020 - 05:24

Trust me, there's no better time than now for building a tool for employee productivity tracking. Even before the COVID-19 pandemic outbreak, around 70% of the global workforce telecommuted at least one day in a week. And after the pandemic ends, the trend of remote work is expected to continue as the crisis has already accelerated digital transformation and changed the way we work.

Despite tangible benefits like reduced office lease and utility costs, remote work poses a serious challenge to business continuity and employee productivity. This makes many companies search for software that ensures effective monitoring of employees’ performance and helps improve their productivity. And that’s where you can step in with your product.

Puzzled by Choice of Features for Your Productivity Tracking Software?

ITQSOFT’s professionals will analyze your project and help you define an optimal toolset for your employee productivity tracking software.

Сore functionality for your tracking software

ITQSOFT’s experience in software product development and helping businesses move to telework allows me to summarize the most wanted features of employee tracking software. All these features can be powered by AI, a smart technology that is growing fast now. According to Gartner, AI is expected to become the source of 80% of emerging technologies by 2021.

If you want to succeed in the market of employee productivity tracking software, I recommend you to consider including the following features in your product:

Time management

Your product should be able to define a working day duration based on tracking employees’ log-in and log-out. However, employees can work offline, too. For example, they can discuss some issue over the phone with a colleague or have a meeting with a customer. Therefore, I recommend enabling users of your software to manually log time spent on offline work-related tasks. Also, don’t forget about mobile remote workers and support your product with a relevant mobile app. Let me provide you with an example of such an app that ITQSOFT`s developers built for one of the customers. It was a time-tracking app that allowed logging working time manually or automatically (upon detecting the Wi-Fi network).

User behavior monitoring

Any employee tracking software has features for collecting data like a number of emails, conversations, meetings and records, who accesses and edits files, and more. But it’s not enough for modern employers, and I believe your product should also be able to determine behavioral patterns that negatively affect employee productivity, such as wasting time on social media and internet surfing for personal reasons. According to the statistics, businesses face an estimated 40% productivity loss each year due to non-work related internet surfing. So, I recommend you to enable your product to track app usage and visited sites, including such time thieves as Facebook, Twitter and YouTube. What’s more, you can enrich your product with the capability to block any sites considered to be distracting. Let me provide you with an example. For one of our customers, we developed an anti-procrastination desktop app that allowed users either filter certain sites or completely block internet access during the working hours.

As an optional feature, you can make your software count keystrokes, switching between apps and take screenshots every 15 minutes, which will also help employers to measure employee productivity for certain job positions, e.g., software developers or content managers.

Project and task management

Employee monitoring software should provide project management capabilities and show statuses, progress and deadlines for projects and tasks in real time. For managers, it ensures full visibility into employee working activities and allows measuring their performance. For employees, it’s a convenient way to manage tasks. They can organize them in groups, receive relevant notifications about upcoming deadlines, and more. ITQSOFT implemented such functionally in one of our projects. It was an app that enabled employees to easily manage their working tasks due to organizing them into 4 groups: unplanned tasks, organized tasks, related activities and completed tasks.

Analytics and reporting

From my experience, effective employee tracking software should not only collect various metrics but also be able to analyze them. The analysis is needed to measure employee productivity and reveal areas for improvement. For example, employers can get insights about prioritizing tasks differently or automating repetitive manual tasks. To facilitate the analysis, your employee productivity tracking software should be able to present all relevant collected metrics in a convenient way, for example, in the form of dashboards and diagrams. Thus, managers will easily see the full picture of employee performance and compare productivity scores of different employees, which influences decision-making about promotions, salary reviews, additional training, and more. Thus, for one of our customers, we implemented a solution that allowed them to evaluate efforts and resources spent on projects due to merging a variety of reports and metrics from different internal sources into one integrated system.

Employee privacy considerations

When creating your employee productivity tracking software, don’t forget about compliance regulations like HIPAA or GDPR that require securing sensitive data related to employees. To ensure protecting remote employee privacy, I recommend introducing the following restrictions to your product:

Monitoring employee activities only during working hours.
Blurring screenshots taken at regular intervals to see whether an employee is active without revealing the contents of the page.
Not recording sensitive information like passwords and bank card details.

Start building your feature-rich software for employee productivity tracking

I’ve highlighted the most recommended features for your employee productivity tracking software. I advise you to leverage AI capabilities as implementing AI-based features is quite affordable now due to the availability of open-source and highly functional frameworks.

When you define a core feature set, you can start planning the development of your employee productivity tracking software. To reduce the product’s time-to-market, I suggest going for iterative development. Thus, depending on the complexity, your MVP can be ready in 3-6 months. Also, I suggest automating development and testing and choose cloud-native architecture, which will help you launch your product faster.

If you need help with developing your MVP, enriching your product with AI-powered features or solving any challenges related to productivity tracking software development, you are welcome to reach out to ITQSOFT ’s experts for professional advice.

Software Dev.

Legacy System Modernization

admin — Mon, 21 Dec 2020 04:24:20 +0000

Legacy System Modernization admin Mon, 12/21/2020 - 05:24

Story #1 Accounting software migration to Azure: Towards easier maintenance and updates

A manufacturer and distributor of accounting and payroll software approached ITQSOFT to update their desktop software products developed with legacy techs.

Motives for migration

The company struggled with software maintenance and update difficulties. The product’s competitiveness was at serious risk since the company couldn’t support quick and easy product evolution to meet new customer demands.

Migration results

ITQSOFT has modernized a legacy desktop software product into an Azure-based web application. This has allowed overcoming limited capabilities of client-dependent desktop apps – minimize disruption, and, consequently, costs and time to product evolution.

The updated system supports frequent and easy changes and integrations. The functionality is expanded with such capabilities as e-payments, automated tax calculation and online subscription service.

Also, placed in the cloud, the system serves as the single location for information storage and sharing for product users who can access and work with the consistent data anytime, anywhere, using any device.

Migration success factors

Recapturing current software requirements (including all architectural design elements, connections, interdependencies). Many legacy systems lack comprehensive and up-to-date requirements documentation. However, clear and relevant application documentation helps shorten the learning curve for modernization team members, accurately identify potentially re-usable components for the renewed system and clearly predict the effect of future changes in software – and, therefore, to carry out the migration faster and exclude significant disruptions in business processes.
Re-architecting to a modular stateless architecture. Shaping a revitalized application into a set of independent modules allows leveraging horizontal scaling capacity in the cloud, preserving high availability and adding new functionality and integrations easier. Stateless (with a state only being maintained in the browser) nature makes the application even more scalable and portable, and it integrates better with other cloud-based services. It also helps save user experience from any infrastructure issues (servers going down).

Story # 2 Cashback services migration to AWS: Towards better availability

A leading US-based cashback services provider of online shopping, travel and entertainment services and products in 100+ countries wanted to modernize several software modules (a web portal, statistics, payments, commission, mailings, and others).

Motives for modernization

The company struggled with the lack of scalability of the IT infrastructure supporting their operations. The ever-rising number of website visitors resulted in server overloads and a significant decrease in service performance. Fewer consumers could finish the purchasing journey at the time of overloads, which led to a significant drop in revenue.

Modernization results

ITQSOFT`s team migrated the entire infrastructure from 20 dedicated servers to AWS. The cloud-operating, scalable system can confidently withstand high loads. Also, the company now avoids the considerable expenses caused by running their services on dedicated servers.

Migration success factors

Share-nothing architecture. When the nodes are made not to share memory and storage and have the data strictly partitioned, it’s possible to eliminate single points of failure and make the overall system to operate and upgrade without a system-wide shutdown. It also allows scaling via simple adding of new nodes to remain available even in case of high loads.

Story # 3 SOA implementation and migration to JavaScript of a web portal with 400 mln subscriptions: Towards better competitiveness

A large travel agency that offers a wide range of travel products including flights, cruises, vacation packages, insurance, and more turned to ITQSOFT to modernize their web portal with 400 mln subscriptions.

Motives for modernization

The company wanted to align their online booking platform – the major means of customer interaction – with the customers’ expectations and boost brand visibility in the highly competitive market.

Modernization results

ITQSOFT’s team brought the modern look and feel to the legacy portal and enabled quick and easy functionality upgrades. At the moment, Feefo – a global provider of genuine customer reviews – rates the travel agency as ‘Excellent’ at 95% of customer satisfaction.

Migration success factors

SOA implementation. SOA is an architectural design principle, which makes an application a set of loosely coupled services communicating via APIs. Each service is responsible for particular information requests, for example, hotel deals and vacation packages, and for checking the relevance of featured deals. This allows the business to quickly introduce changes and fixes to the application, adapt business processes to new evolving needs and add integrations.
The independent front end. The completely isolated front end allows introducing SPA (single page application) front end for smooth and sleek dynamic user experience.

Impressed With Modernization Results?

ITQSOFT’s team can bring to the table both legacy and modern skills to help you improve the agility, looks, and efficiency of your software and drive business value.

General tips to maximize value and reduce risks of legacy software modernization

Deep assessment of the legacy application code and design to understand the economic and technical feasibility of a modernization project.
High priority to risk management and keeping modernization as a manageable, transparent and predictable process. Thus, it will be possible to roll back modernization if something starts to go downhill.
Splitting a legacy application to smaller loosely coupled parts (preferably, microservices). This helps implement changes step-by-step and avoid a long “code freeze” – an inability to either add new features or fix hot issues.
Thorough testing and application monitoring. If modernized components have defects, it can lead to significant business process disruptions and operational downtime.

Unlock the new value from your legacy software!

Undeniably beneficial legacy system modernization projects come together with risks and challenges that should not be underestimated. If you plan significant modernization of your obsolete software systems, be sure to have an experienced multi-functional in-house team or turn to an established provider of relevant services. Thus, my colleagues at ITQSOFT will be happy to support you at any stage of a software modernization journey, just give them a shout.

Software Dev.

Capabilities of React.js

admin — Sun, 21 Jun 2020 03:24:22 +0000

Capabilities of React.js admin Sun, 06/21/2020 - 05:24

What is React?

React is not a frontend framework but rather a library offering a new approach to build view. It creates a virtual DOM to track changes when the application state is updated and uses the virtual DOM to update only those parts of the page which have been changed. Since all DOM manipulations occur simultaneously in an efficient way, it makes UI lightning fast.

Why should I use React?

Since React is just a view library it is easy to apply it to the existing code base and decide if it fits or not.

It uses the declarative approach to describe components, and the components API is pretty small so the learning curve is not steep. It is also handy for teamwork because components have a predefined structure.

React is isomorphic. It is possible to use React everywhere where you can execute JavaScript. If you need to improve the initial page loading and do SEO, you can render the page on the server side with a help of Node.js or Java 8 Nashorn. Or you can even use it on TV and game consoles like Netflix does.

The library is supported by Facebook and has already been used by Facebook in production on different projects.

The community support is also growing rapidly and a number of companies (Netflix, AirBnB, SoundCloud, Yahoo!, Codecademy to name just a few) choose React for production.

React core concepts

Component

The basic unit of a React application is a component. A React component is a mix of markup and JavaScript which is rendered into an HTML fragment.

Components are nested into each other in the same way as HTML tags.

A simple react component looks like this:

var MyComponent = React.createClass({
    render: function () {
        return <div>This component is rendered as a block with a text</div>;
    }
});

The same component parsed to JavaScript:

var MyComponent = React.createClass({displayName: "MyComponent",
    render: function () {
        return React.createElement("div", null, "This component is rendered as a block with a text");
    }
});

Mixing markup and JavaScript in a single place may seem a bad idea but this is what any JavaScript UI library does. Since there are still tasks that cannot be solved with only HTML and CSS, sometimes a JavaScript solution turns out to be more efficient. So it is acceptable to use JavaScript to change the view as long as you have your application logic handled separately. From this point of view, React components are just an extension of the existing HTML elements.

Imagine you have a <Header> component which is supposed to render a title in a nice way, and you want it to stick to the top during scrolling. It is easy to extend HTML with a new 'element' to encapsulate this 'stick to the top' logic.

<StickyTopComponent>
    <Header>Company Name</Header>
</StickyTopComponent>

<StickyTopComponent> is responsible for displaying its child elements always on top.

As long as the application logic lives in a separate place, you have to be able to pass data to the view layer to display it. React components do this in HTML in a similar way. All you need to do is to pass values through attributes.

<Tooltip position="left">Please, fill this field</Tooltip>

Now <Tooltip> knows that it should appear to the left of another element and can draw a pointer on the right side.

JSX

Essentially React components are simple objects, but thanks to JSX they can be presented much like HTML tags. JSX is XML-looking syntactic sugar like the syntax inside JavaScript code.

Moreover, JSX enables you to pass object as an attribute value:

var List= React.createClass({
    render: function () {
        return (
            <ul>
                {this.props.values.map(function (val) {
                    return <li>{val}</li>;
                })}
            </ul>
        );
    }
});
 
// ...
<List values={['milk','sugar','meat']}/>

You can even pass a function to a component which is widely used for event listeners and communication between parent and child components.

Eventually, this is parsed to JavaScript and you just pass an object to the function.

var List= React.createClass({displayName: "List",
    render: function () {
        return (
            React.createElement("ul", null, 
                this.props.values.map(function (val) {
                    return React.createElement("li", null, val);
                })
            )
        );
    }
});

// ...
React.createElement(List, {values: ['milk','sugar','meat']})

Since attribute names are converted to object fields, JSX expects the usage of 'className' instead of 'class' and 'htmlFor' instead of 'for' attributes.

It is handy to use JSX because you see where representation is and where other calculations are. It is also easier for designers to change small pieces of UI without digging into JavaScript logic. However, JSX syntax is optional and you could just as well write your components in JavaScript.

State and Props

React components are called state-full because the output of the component render() function is always determined by the data a component contains. There are two places where new data are passed to a component: props and state.

var InputCounter = React.createClass({
    getInitialState: function () {
        return {count: 0};
    },
    render: function () {
        return <div>{this.props.label} : <input type='text' onInput={this.countSymbols}/> {this.state.count}</div>;
    },
    countSymbols: function (e) {
        this.setState({count: e.target.value.length});
    }
});
 
// ...
<InputCounter label='How many symbols in'/>

A component is instantiated with 'props' and 'state' fields. A properties object is a map of attributes and their values. Props are used to pass data from the parent to child components. A child component must not change the properties it has received from the parent component. The internal condition of a component is represented by the state object and its data can be changed by the component itself.

The ability to encapsulate a component's internal state simplifies the separation of the application logic from the view layer. A component should only change state itself when it is related to its representation and have to pass manipulations related to the application data.

Reusable components

Components that do not contain application logic can be reused in different ways. React encourages writing reusable components and provides an API to unify the components structure.

Writing a component you can define which properties it can have and what the required type for each property is. You can also define the component's default properties and default state. Having this done in a declarative way is very useful to work with the third-party components.

Moreover, properties can be passed through components making it easy to create a thin wrapper around the nested components.

Virtual DOM

React keeps in memory a simple object tree of all components which is called the virtual DOM. Whenever the application state changes and it is required to update the UI, the virtual DOM is used to find the minimal set of operations to bring the view from the previous condition to the new one.

Let’s take a look at the component below:

var Example1Component = React.createClass({
    render: function () {
        if (this.props.isMain) {
            return <p className="main"><strong>Title</strong></p>;
        } else {
            return <p className="secondary">Title</p>;
        }
    }
});

If the component was used as <Example1Component isMain={true}/> and it is changed to be <Example1Component isMain={false}/>, then React will calculate that it is only needed to change the class on <p> element and replace <strong> with a text node.

It is a simple example but it provides a basic understanding of React diff-algorithm.

In a more complex application, several levels of nested components will create an object tree. In this case when setState() is called for the top most component, it recalculates all nodes below.

In order to optimize re-rendering React starts from the lowest nodes and compares only components on the same level of the tree.

Child components are compared by classes. So if a component had <Link/> child but now it should render <Button/>, it will not compare these different components but just replace the older one.

React also optimizes lists comparison by assigning keys to list components. If components in the list have keys, it is much easier to find which component has been changed, added or removed.

All these optimizations are possible because React provides an abstraction from direct DOM manipulation describing components as objects and composing them into a virtual DOM.

Event handling

React creates its own event system which is fully compatible with W3C specification. All browser’native events are wrapped by instances of SyntheticEvent. It provides a cross-browser interface to a native event. That means you do not need to worry about inconsistent event names and fields. Moreover, React event system is implemented through event delegation and also has a pool of event objects to reduce memory overhead.

How to build a sophisticated app using React

The main question you will face when you decide to use React is: if React is just a view layer, how can I build an enterprise application with a sophisticated client side logic using it?

Building applications with React is simple because you can integrate it with any architecture and framework you know using it just like a template engine. Components receive state and props, calculate what UI should look like and then render or update the DOM. Components also define event listeners to handle UI events. Events are processed and the state is updated again. That is pretty much everything that you need to know to start using React.

Reusable components

When you write a reusable component you want it to be possible to use it in different places in your application or to share it with other developers. Therefore, a component should be as generic as possible. It should work with any data model passed to the state and the logic inside the component should only work for UI calculations. It is a good practice to wrap a general component in a container component that might convert an application specific data model to the state model of the wrapped component.

Flux

In order for the application to know about user interactions and data changes, a component must never change the data itself. Instead component fires events that application should process some action and change some data. When data are updated, they are passed back to the component by updating its state. Components never change the state of other components directly but fire events and then the application defines the components the state of which should be changed. This means that data flow in a single direction from components to an application and back to the components.

An application architecture that describes the unidirectional data flow is called Flux. According to Flux, when a component receives an event it sends an action object with some payload. The application has a single Dispatcher that handles all actions and distributes them to registered stores. The stores contain the data from a specific application domain and the logic to operate with these data. A component listens to changes from the store and updates its state.

Flux architecture is straight and aimed at simplifying the data flow in sophisticated applications but there are possible pitfalls you should be aware of while using Flux.

Imagine you have two instances of the same component. That means that they trigger the same actions. How to distinguish which component triggers an action? One solution is to create a specific wrapper around each component. Wrappers handle events from the embedded component and fire own actions. Using this approach you will have to write a lot of code for wrappers and actions. Another solution is to have an ID for each component and send it with actions payload. In this case your stores should know IDs of the components they want to communicate with. Therefore, the store should take an ID from a component when it is registered and check that the actions target ID is appropriate.

Handling AJAX

It is up to you how to organize client-server communications in your application. What’s more, even Flux pattern does not describe how to work with asynchronous code. There are two places where you could handle AJAX responses. The first is right inside the store where you make a request. It is a decent place if you do not have other stores which have to update data based on the same resource. Another option is to fire an action when a response is received and put its data to the action payload. The dispatcher then distributes the action to stores.

In the same way you could handle another asynchronous operation. If an operation updates data of its store only, it can be handled right in the place. If it has to change some common data, it should trigger an action.

Data model

Stores are environments where you work with your application data. There are no rules regarding what they should look like. It is perfectly acceptable to use Backbone.js or any other library to create data models. However, the most powerful solution is to use immutable data structures. An immutable object perfectly fits the React rendering process because it is easy to check if an object has been changed or not. An immutable object cannot be changed. When you are changing a field of an immutable object, you get a link to a new object. It is almost the same: all its fields, except one, point to them same values. To check if an object has been changed, you need to check if the link to an object and the link you have on hand are the same. You do not have to iterate the whole object tree and compare each nested field. This is why it is extremely useful when React considers re-rendering a component.

Conclusion

Applications built on React use new principles that have not been used in web development before. It is a perfect tool to make high-performance presentation layer for your application. And it can be even faster if you take the advantage of immutable data structures. But with the new approaches to the rendering process, it also gently nudges you to rethink the whole architecture. As always, you should put “reusable” at the core of the code making your components generic and separate view from the logic. There are plenty of Flux implementations you can choose from, including the brand new framework Relay. But beyond any doubt React is a library worth to take a look at.

Software Dev.

Software for Strategic Sourcing

admin — Wed, 21 Dec 2016 04:25:04 +0000

Software for Strategic Sourcing admin Wed, 12/21/2016 - 05:25

Sourcing software features

Supplier self-registration

Suppliers go through quick and easy registration in the system, providing their contacts and relevant business information. A buying company can configure the registration fields to collect the information they need for supplier assessment.

Automatic monitoring of current offers from suppliers

In an eSourcing solution, buyers can analyze and compare product and service offerings from different suppliers.

Bidding management

A buying company can create tenders, invite potential suppliers to take part in them, and select the most attractive offers. Suppliers can view and bid on the organization's requests in real time, and even update their price offers in response to competitors' price updates.

Supplier selection

Sourcing software can facilitate vendor selection by offering such capabilities as side-by-side comparison of vendor proposals and their qualification ratings. Also, the system can be configured to automatically evaluate registered suppliers according to the criteria specified by the buying company.

Involve Experts to Optimize Your Strategic Sourcing

ITQSOFT can help you choose a ready-to-go product for strategic sourcing best meeting your business needs, or provide you with a custom solution roadmap.

Supplier risk assessment

An eSourcing solution enables the analysis of supplier performance to reveal possible risks (e.g., reputational, financial, regulatory), which will save companies from supply chain disruptions and financial losses.

Purchasing optimization

The function of automated creation of purchase orders from approved bids will help speed up the procurement process and reduce the burden on the purchasing department.

Stock control

Integrated with inventory management software, a sourcing solution can help spot items running out of stock early and send automated low-stock alerts.

Sourcing software: top 3 tools

Dynamics 365 Supply Chain Management

The app allows organizations to evaluate and compare vendor bids, and customize sourcing and purchasing workflows (for example, a vendor approval workflow for specific products and services).

Pricing: $180 per user/month.

Oracle Supply Chain Management: Procurement

The solution has a wide range of features, including automated creation of purchase orders from approved requisitions, simple registration of suppliers, fast processing of contracts, real-time visibility into transaction statuses.

Pricing: by request to the vendor

SAP Ariba: Supplier Management

The solution enables supplier segmentation (e.g., to give the highest strategic priority to suppliers of high-volume or high-value products), provides analysis of suppliers based on, for example, location or price, monitors reputational, financial, compliance and other risks in real time.

Pricing: by request to the vendor

Improve your purchasing with sourcing software

With an easy-to-use supplier sourcing tool you can compare supplier bids, choose the ones that suit your company's needs best, and monitor your procurement process for risk exposure. If you need assistance in developing and implementing sourcing software,

Software Dev.