Providence: Cataloguing and Data/media Management Application

README: Providence version 1.7.17

About CollectiveAccess

CollectiveAccess is a web-based suite of applications providing a framework for management, description, and discovery of complex digital and physical collections in museum, archival, and research contexts. It is comprised of two applications. Providence is the “back-end” cataloging component of CollectiveAccess. It is highly configurable and supports a variety of metadata standards, data types, and media formats. Pawtucket2 is CollectiveAccess' general purpose public-access publishing tool. It provides an easy way to create web sites around data managed with Providence. (You can learn more about Pawtucket2 at https://github.com/collectiveaccess/pawtucket2)

CollectiveAccess is freely available under the open source GNU Public License version 3.

About CollectiveAccess 1.7.17

Version 1.7.17 is a maintenance release with these bug fixes and minor improvements:

• Add option to display nested type hierarchies as indented list in menus rather than nested menus.
• Fix fatal error in library checkout due to incorrect type checking in display template parser.

Note that this version is not yet compatible with PHP version 8. Please use versions 7.3 or 7.4.

Installation

First make sure your server meets all of the requirements. Then follow the installation instructions.

Updating from a previous version

NOTE: The update process is relatively safe and rarely, if ever, causes data loss. That said BACKUP YOUR EXISTING DATABASE AND CONFIGURATION prior to updating. You almost certainly will not need the backup, but if you do you'll be glad it's there.

To update, decompress the CollectiveAccess Providence 1.7.17 tar.gz or zip file and replace the files in your existing installation with those in the update. Take care to preserve your media directory (media/), local configuration directory (app/conf/local/), any local print templates (app/printTemplates/) and your setup.php file.

If you are updating from a version prior to 1.7, you must recreate your existing setup.php as the format has changed. Rename the existing setup.php to setup.php-old and copy the version 1.7.17 setup.php template in setup.php-dist to setup.php. Edit this file with your database login information, system name and other basic settings. You can reuse the settings in your existing setup.php file as-is. Only the format of setup.php has changed. If you are updating from version 1.7.x you do not need to change your setup.php file.

Once the updated files are in place navigate in your web browser to the login screen. You will see this message:

Your database is out-of-date. Please install all schema migrations starting with migration #xxx. Click here to automatically apply the required updates.

The migration number may vary depending upon the version you're upgrading from. Click on the here link to begin the database update process.

Version 1.7 introduced zoomable page media for multipage documents such as PDFs, Microsoft Word or Powerpoint. Systems migrated from pre-1.7 versions of CollectiveAccess will not have these zoomable media versions available causing the built-in document viewer to fail. If your system includes multipage documents you should regenerate the media using the command-line caUtils utility in support/bin. The command to run (assuming your current working directory is support/) is:

bin/caUtils reprocess-media 

Be sure to run it as a user that has write permissions on all media. You do not need to reprocess media if you are updating from a 1.7.x system.

Installing development versions

The latest development version is always available in the develop branch (https://github.com/collectiveaccess/providence/tree/develop). Other feature-specific development versions are in branches prefixed with dev/. To install a development branch follow these steps:

1. clone this repository into the location where you wish it to run using git clone https://github.com/collectiveaccess/providence.
2. by default, the newly cloned repository will use the main branch, which contains code for the current release. Choose the develop branch by running from within the cloned repository git checkout develop.
3. install the PHP package manager Composer if you do not already have it installed on your server.
4. run composer from the root of the cloned repository with composer.phar install. This will download and install all required 3rd party software libraries.
5. follow the release version installation instructions to complete the installation.

Useful Links

• Web site: https://collectiveaccess.org
• Documentation: https://manual.collectiveaccess.org
• Demo: https://demo.collectiveaccess.org/
• System requirements: https://manual.collectiveaccess.org/setup/systemReq.html
• Forum: https://www.collectiveaccess.org/support

To report issues please use GitHub issues.

Other modules

Pawtucket2: https://github.com/collectiveaccess/pawtucket2 (The public access front-end application for Providence)

Download Details:

Author: Collectiveaccess
Source Code: https://github.com/collectiveaccess/providence 
License: GPL-3.0 license

#php #data #media #management #application 

BlockSuite: The Open-source Collaborative Editor Project Behind AFFiNE

BlockSuite

BlockSuite (pronounced "block sweet") is the open-source editor project behind AFFiNE. It provides an out-of-the-box block-based editor built on top of a framework designed for general-purpose collaborative applications. This monorepo maintains both the editor and the underlying framework.

• 👉 Try BlockSuite-based AFFiNE online
• 🚀 Edit this page in BlockSuite

⚠️ This project is under heavy development and is in a stage of rapid evolution. Stay tuned or see our roadmap here!

Introduction

BlockSuite works very differently than traditional rich text frameworks:

• For the data model, BlockSuite eliminates the need to work with data-driven DSLs (e.g., operations, actions, commands, transforms). Instead, it utilizes CRDT as the single source of truth, offering a strongly-typed block tree model built on Yjs. With BlockSuite, manipulating blocks becomes as simple as updating a todo list. Moreover, by fully harnessing the power of CRDT, it supports zero-cost time travel, real-time collaboration, and out-of-the-box pluggable persistence backends.
• For rich text editing, BlockSuite seamlessly organizes rich text content into discrete blocks. In BlockSuite, a document with 100 paragraphs can be rendered into 100 text blocks or 100 individual rich text editor instances, effectively eliminating the outdated practice of consolidating all content into a single, risky contenteditable monolith.
• At the rendering layer, BlockSuite remains framework agnostic. It doesn't limit the block tree rendering to the DOM. Not only does it implement its entire document editing UI using Web Components, but it also offers a hybrid canvas-based renderer for whiteboard content sections. Both renderers can coexist on the same page and share a unified centralized data store.

BlockSuite is not intended to be yet another plugin-based rich text editing framework. Instead, it encourages building various collaborative applications directly through whatever UI framework you're comfortable with. To this end, we will try to open-source more foundational modules as reusable packages for this in the BlockSuite project.

Although BlockSuite is still in its early stages, you can already use the @blocksuite/editor package, the collaborative editor used in AFFiNE Alpha. Note that this editor is also a web component and is completely framework-independent!

Resources

• 🎁 Examples
  • Nightly Playground (🔗 source)
  • The SimpleAffineEditor Example (🔗 source)
  • AFFiNE Alpha Editor (🔗 source)
  • Multiple Workspace Example with React (🔗 source)
  • CodeSandbox Starter Template
  • BlockSuite Monorepo in CodeSandbox
• 🗓️ GitHub Project
• 📍 GitHub Issues
• 🎙️ GitHub Discussions
• 💬 Discord Channel
• 🏠 AFFiNE Community
• 🚀 Releases

Getting Started

The @blocksuite/editor package contains the editor built into AFFiNE. Its nightly versions are released daily based on the master branch, and they are always tested on CI. This means that the nightly versions can already be used in real-world projects like AFFiNE at any time:

pnpm i @blocksuite/editor@nightly

If you want to easily reuse most of the rich-text editing features, you can use the SimpleAffineEditor web component directly (code example here):

import { SimpleAffineEditor } from '@blocksuite/editor';
import '@blocksuite/editor/themes/affine.css';

const editor = new SimpleAffineEditor();
document.body.appendChild(editor);

Or equivalently, you can also use the declarative style:

<body>
  <simple-affine-editor></simple-affine-editor>
  <script type="module">
    import '@blocksuite/editor';
    import '@blocksuite/editor/themes/affine.css';
  </script>
</body>

👉 Try SimpleAffineEditor online

However, the SimpleAffineEditor here is just a thin wrapper with dozens of lines that doesn't enable the opt-in collaboration and data persistence features. If you are going to support more complicated real-world use cases (e.g., with customized block models and configured data sources), this will involve the use of these three following core packages:

• The packages/store package is a data store built for general-purpose state management.
• The packages/blocks package holds the default BlockSuite editable blocks.
• The packages/editor package ships a complete BlockSuite-based editor.

pnpm i \
  @blocksuite/store@nightly \
  @blocksuite/blocks@nightly \
  @blocksuite/editor@nightly

And here is a minimal collaboration-ready editor showing how these underlying BlockSuite packages are composed together:

🚧 Here we will work with the concepts of Workspace, Page, Block and Slot. These are the primitives for building a block-based collaborative application. We are preparing a comprehensive documentation about their usage!

import '@blocksuite/blocks';
import { Workspace, Page } from '@blocksuite/store';
import { AffineSchemas } from '@blocksuite/blocks/models';
import { EditorContainer } from '@blocksuite/editor';

function main() {
  // Create a workspace with one default page
  const workspace = new Workspace({ id: 'test' }).register(AffineSchemas);
  const page = workspace.createPage('page0');

  // Create default blocks in the page
  const pageBlockId = page.addBlock('affine:page');
  const frameId = page.addBlock('affine:frame', {}, pageBlockId);
  page.addBlock('affine:paragraph', {}, frameId);

  // Init editor with the page store
  const editor = new EditorContainer();
  editor.page = page;
  document.body.appendChild(editor);
}

main();

For React developers, check out the @blocksuite/react doc for React components and hooks support.

Current Status (@blocksuite/editor)

For more detailed planning and progress, please checkout our GitHub project.

• Basic text editing
  • ✅ Paragraph with inline style
  • ✅ Nested list
  • ✅ Code block
  • ✅ Markdown shortcuts
• Block-level editing
  • ✅ Inline text format bar
  • ✅ Inline slash menu
  • ✅ Block hub
  • ✅ Block drag handle
  • ✅ Block-level selection
• Rich-content
  • ✅ Image block
  • 🚧 Database block
  • 📌 Third-party embedded block
• Whiteboard (edgeless mode)
  • ✅ Zooming and panning
  • ✅ Frame block
  • ⚛️ Shape element
  • ⚛️ Handwriting element
  • 🚧 Grouping
• Playground
  • ✅ Multiplayer collaboration
  • ✅ Local data persistence
  • ✅ E2E test suite
• Developer experience
  • ✅ Block tree update API
  • ✅ Zero cost time travel (undo/redo)
  • ✅ Reusable NPM package
  • ✅ React hooks integration
  • 📌 Dynamic block registration

Icons above correspond to the following meanings:

• ✅ - Beta
• ⚛️ - Alpha
• 🚧 - Developing
• 📌 - Planned

Building

See BUILDING.md for instructions on how to build BlockSuite from source code.

Contributing

BlockSuite accepts pull requests on GitHub. Before you start contributing, please make sure you have read and accepted our Contributor License Agreement. To indicate your agreement, simply edit this file and submit a pull request.

Download Details:

Author: toeverything
Source Code: https://github.com/toeverything/blocksuite 
License: MPL-2.0 license

#react #editor #components #block #state #management #webcomponents 

200 Bytes to Never Think About React State Management Libraries Ever

Unstated Next

200 bytes to never think about React state management libraries ever again

• React Hooks use them for all your state management.
• ~200 bytes min+gz.
• Familiar API just use React as intended.
• Minimal API it takes 5 minutes to learn.
• Written in TypeScript and will make it easier for you to type your React code.

But, the most important question: Is this better than Redux? Well...

• It's smaller. It's 40x smaller.
• It's faster. Componentize the problem of performance.
• It's easier to learn. You already will have to know React Hooks & Context, just use them, they rock.
• It's easier to integrate. Integrate one component at a time, and easily integrate with every React library.
• It's easier to test. Testing reducers is a waste of your time, make it easier to test your React components.
• It's easier to typecheck. Designed to make most of your types inferable.
• It's minimal. It's just React.

So you decide.

See Migration From Unstated docs →

Install

npm install --save unstated-next

Example

import React, { useState } from "react"
import { createContainer } from "unstated-next"
import { render } from "react-dom"

function useCounter(initialState = 0) {
  let [count, setCount] = useState(initialState)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment }
}

let Counter = createContainer(useCounter)

function CounterDisplay() {
  let counter = Counter.useContainer()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <span>{counter.count}</span>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

function App() {
  return (
    <Counter.Provider>
      <CounterDisplay />
      <Counter.Provider initialState={2}>
        <div>
          <div>
            <CounterDisplay />
          </div>
        </div>
      </Counter.Provider>
    </Counter.Provider>
  )
}

render(<App />, document.getElementById("root"))

API

createContainer(useHook)

import { createContainer } from "unstated-next"

function useCustomHook() {
  let [value, setValue] = useState()
  let onChange = e => setValue(e.currentTarget.value)
  return { value, onChange }
}

let Container = createContainer(useCustomHook)
// Container === { Provider, useContainer }

<Container.Provider>

function ParentComponent() {
  return (
    <Container.Provider>
      <ChildComponent />
    </Container.Provider>
  )
}

<Container.Provider initialState>

function useCustomHook(initialState = "") {
  let [value, setValue] = useState(initialState)
  // ...
}

function ParentComponent() {
  return (
    <Container.Provider initialState={"value"}>
      <ChildComponent />
    </Container.Provider>
  )
}

Container.useContainer()

function ChildComponent() {
  let input = Container.useContainer()
  return <input value={input.value} onChange={input.onChange} />
}

useContainer(Container)

import { useContainer } from "unstated-next"

function ChildComponent() {
  let input = useContainer(Container)
  return <input value={input.value} onChange={input.onChange} />
}

Guide

If you've never used React Hooks before, I recommend pausing and going to read through the excellent docs on the React site.

So with hooks you might create a component like this:

function CounterDisplay() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return (
    <div>
      <button onClick={decrement}>-</button>
      <p>You clicked {count} times</p>
      <button onClick={increment}>+</button>
    </div>
  )
}

Then if you want to share the logic behind the component, you could pull it out into a custom hook:

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment }
}

function CounterDisplay() {
  let counter = useCounter()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

But what if you want to share the state in addition to the logic, what do you do?

This is where context comes into play:

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment }
}

let Counter = createContext(null)

function CounterDisplay() {
  let counter = useContext(Counter)
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

function App() {
  let counter = useCounter()
  return (
    <Counter.Provider value={counter}>
      <CounterDisplay />
      <CounterDisplay />
    </Counter.Provider>
  )
}

This is great, it's perfect, more people should write code like this.

But sometimes we all need a little bit more structure and intentional API design in order to get it consistently right.

By introducing the createContainer() function, you can think about your custom hooks as "containers" and have an API that's clear and prevents you from using it wrong.

import { createContainer } from "unstated-next"

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment }
}

let Counter = createContainer(useCounter)

function CounterDisplay() {
  let counter = Counter.useContainer()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

function App() {
  return (
    <Counter.Provider>
      <CounterDisplay />
      <CounterDisplay />
    </Counter.Provider>
  )
}

Here's the diff of that change:

- import { createContext, useContext } from "react"
+ import { createContainer } from "unstated-next"

  function useCounter() {
    ...
  }

- let Counter = createContext(null)
+ let Counter = createContainer(useCounter)

  function CounterDisplay() {
-   let counter = useContext(Counter)
+   let counter = Counter.useContainer()
    return (
      <div>
        ...
      </div>
    )
  }

  function App() {
-   let counter = useCounter()
    return (
-     <Counter.Provider value={counter}>
+     <Counter.Provider>
        <CounterDisplay />
        <CounterDisplay />
      </Counter.Provider>
    )
  }

If you're using TypeScript (which I encourage you to learn more about if you are not), this also has the benefit of making TypeScript's built-in inference work better. As long as your custom hook is typed, then everything else will just work.

Tips

Tip #1: Composing Containers

Because we're just working with custom React hooks, we can compose containers inside of other hooks.

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment, setCount }
}

let Counter = createContainer(useCounter)

function useResettableCounter() {
  let counter = Counter.useContainer()
  let reset = () => counter.setCount(0)
  return { ...counter, reset }
}

Tip #2: Keeping Containers Small

This can be useful for keeping your containers small and focused. Which can be important if you want to code split the logic in your containers: Just move them to their own hooks and keep just the state in containers.

function useCount() {
  return useState(0)
}

let Count = createContainer(useCount)

function useCounter() {
  let [count, setCount] = Count.useContainer()
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  let reset = () => setCount(0)
  return { count, decrement, increment, reset }
}

Tip #3: Optimizing components

There's no "optimizing" unstated-next to be done, all of the optimizations you might do would be standard React optimizations.

1) Optimizing expensive sub-trees by splitting the component apart

Before:

function CounterDisplay() {
  let counter = Counter.useContainer()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
      <div>
        <div>
          <div>
            <div>SUPER EXPENSIVE RENDERING STUFF</div>
          </div>
        </div>
      </div>
    </div>
  )
}

After:

function ExpensiveComponent() {
  return (
    <div>
      <div>
        <div>
          <div>SUPER EXPENSIVE RENDERING STUFF</div>
        </div>
      </div>
    </div>
  )
}

function CounterDisplay() {
  let counter = Counter.useContainer()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
      <ExpensiveComponent />
    </div>
  )
}

2) Optimizing expensive operations with useMemo()

Before:

function CounterDisplay(props) {
  let counter = Counter.useContainer()

  // Recalculating this every time `counter` changes is expensive
  let expensiveValue = expensiveComputation(props.input)

  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

After:

function CounterDisplay(props) {
  let counter = Counter.useContainer()

  // Only recalculate this value when its inputs have changed
  let expensiveValue = useMemo(() => {
    return expensiveComputation(props.input)
  }, [props.input])

  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

3) Reducing re-renders using React.memo() and useCallback()

Before:

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = () => setCount(count - 1)
  let increment = () => setCount(count + 1)
  return { count, decrement, increment }
}

let Counter = createContainer(useCounter)

function CounterDisplay(props) {
  let counter = Counter.useContainer()
  return (
    <div>
      <button onClick={counter.decrement}>-</button>
      <p>You clicked {counter.count} times</p>
      <button onClick={counter.increment}>+</button>
    </div>
  )
}

After:

function useCounter() {
  let [count, setCount] = useState(0)
  let decrement = useCallback(() => setCount(count - 1), [count])
  let increment = useCallback(() => setCount(count + 1), [count])
  return { count, decrement, increment }
}

let Counter = createContainer(useCounter)

let CounterDisplayInner = React.memo(props => {
  return (
    <div>
      <button onClick={props.decrement}>-</button>
      <p>You clicked {props.count} times</p>
      <button onClick={props.increment}>+</button>
    </div>
  )
})

function CounterDisplay(props) {
  let counter = Counter.useContainer()
  return <CounterDisplayInner {...counter} />
}

4) Wrapping your elements with useMemo()

via Dan Abramov

Before:

function CounterDisplay(props) {
  let counter = Counter.useContainer()
  let count = counter.count
  
  return (
    <p>You clicked {count} times</p>
  )
}

After:

function CounterDisplay(props) {
  let counter = Counter.useContainer()
  let count = counter.count
  
  return useMemo(() => (
    <p>You clicked {count} times</p>
  ), [count])
}

Relation to Unstated

I consider this library the spiritual successor to Unstated. I created Unstated because I believed that React was really great at state management already and the only missing piece was sharing state and logic easily. So I created Unstated to be the "minimal" solution to sharing React state and logic.

However, with Hooks, React has become much better at sharing state and logic. To the point that I think Unstated has become an unnecessary abstraction.

HOWEVER, I think many developers have struggled seeing how to share state and logic with React Hooks for "application state". That may just be an issue of documentation and community momentum, but I think that an API could help bridge that mental gap.

That API is what Unstated Next is. Instead of being the "Minimal API for sharing state and logic in React", it is now the "Minimal API for understanding shared state and logic in React".

I've always been on the side of React. I want React to win. I would like to see the community abandon state management libraries like Redux, and find better ways of making use of React's built-in toolchain.

If instead of using Unstated, you just want to use React itself, I would highly encourage that. Write blog posts about it! Give talks about it! Spread your knowledge in the community.

Migration from unstated

I've intentionally published this as a separate package name because it is a complete reset on the API. This way you can have both installed and migrate incrementally.

Please provide me with feedback on that migration process, because over the next few months I hope to take that feedback and do two things:

• Make sure unstated-next fulfills all the needs of unstated users.
• Make sure unstated has a clean migration process towards unstated-next.

I may choose to add APIs to either library to make life easier for developers. For unstated-next I promise that the added APIs will be as minimal as possible and I'll try to keep the library small.

In the future, I will likely merge unstated-next back into unstated as a new major version. unstated-next will still exist so that you can have both unstated@2 and unstated-next installed. Then when you are done with the migration, you can update to unstated@3 and remove unstated-next (being sure to update all your imports as you do... should be just a find-and-replace).

Even though this is a major new API change, I hope that I can make this migration as easy as possible on you. I'm optimizing for you to get to using the latest React Hooks APIs and not for preserving code written with Unstated.Container's. Feel free to provide feedback on how that could be done better.

English | 中文 | Русский | ภาษาไทย | Tiếng Việt
(Please contribute translations!)

Download Details:

Author: jamiebuilds
Source Code: https://github.com/jamiebuilds/unstated-next 
License: MIT license

#react #redux #library #state #management 

Best 7 Tips for Data Science Project Management

Best 7 Tips for Data Science Project Management

Tips to help you plan and execute your data science projects efficiently and successfully.

Project management is an important aspect of data science. Good project management skills will help improve your efficiency and productivity. This article will discuss some tips for managing a data science project.

1. Ask the Right Questions

Asking the right questions is one of the most important steps for a data science project. You need to determine what insights you are trying to obtain from your data. In some cases, you need to ask the right questions even before the data collection process.

2. Gather the Data

Do you have the data available for analysis? If the data is already available, then you may proceed to the next step. If data is not available, you may need to figure out how to collect the data, for example using surveys, or purchase already existing data. If you have to collect your own data, some points to keep in mind include: the quantity of data you need, time needed to collect the data, and the cost of data collection. You need to also make sure the data is representative of the population. Irrespective of where your data is coming from, make sure data collected is of good quality, because bad data produces low quality and unreliable predictive models.

3. Clean and Process Your Data

Any data collected will have imperfections such as the presence of missing data or data may be entered on questionnaires in the wrong format. Raw data will have to be cleaned and preprocessed to render it suitable for further analysis.

4. Decide Which Model is Suitable

You need to decide the model that is suitable for the project. Are you just interested in descriptive data science such as data visualization or in using your data for predictive analysis? For predictive analysis, you may use linear regression (for continuous target variable) or classification (for discrete target variable). If the data does not have a target variable, you may use clustering algorithms for pattern recognition modeling.

5. Build, Evaluate, and Test the Model

For machine learning models such as linear regression, classification, or clustering, you have to build, test, and evaluate your model. This will involve partitioning your data into training and testing sets. Then you need to determine the types of evaluation metrics suitable such as mean square error, R2 score, mean absolute error, overall accuracy, sensitivity, specificity, confusion matrix, cross validation score, etc.

6. Decide If You Need a Team

Are you working on the project on your own or with collaborators? Large scale projects may require a team. If working with a team, make sure you assign roles to team members based on their experience and expertise. Make sure there is effective communication between members in the team, as this will help improve productivity.

7. Write a Project Report to Summarize Your Findings

Once the project is complete, write a project report to summarize the outputs from your analysis. It is important to summarize your results in a way that is not too technical. 

Conclusion

In summary, we have discussed important tips to keep in mind when managing a data science project. Careful preparation, planning, and execution will help you to complete your data science projects in an efficient and timely manner.

Original article source at: https://www.kdnuggets.com/

#datascience #management 

Simple Global State for React with Hooks API Without Context API

React-hooks-global-state

Simple global state for React with Hooks API without Context API

Introduction

This is a library to provide a global state with React Hooks. It has following characteristics.

• Optimization for shallow state getter and setter.
  • The library cares the state object only one-level deep.
• TypeScript type definitions
  • A creator function creates hooks with types inferred.
• Redux middleware support to some extent
  • Some of libraries in Redux ecosystem can be used.

Install

npm install react-hooks-global-state

Usage

setState style

import React from 'react';
import { createGlobalState } from 'react-hooks-global-state';

const initialState = { count: 0 };
const { useGlobalState } = createGlobalState(initialState);

const Counter = () => {
  const [count, setCount] = useGlobalState('count');
  return (
    <div>
      <span>Counter: {count}</span>
      {/* update state by passing callback function */}
      <button onClick={() => setCount(v => v + 1)}>+1</button>
      {/* update state by passing new value */}
      <button onClick={() => setCount(count - 1)}>-1</button>
    </div>
  );
};

const App = () => (
  <>
    <Counter />
    <Counter />
  </>
);

reducer style

import React from 'react';
import { createStore } from 'react-hooks-global-state';

const reducer = (state, action) => {
  switch (action.type) {
    case 'increment': return { ...state, count: state.count + 1 };
    case 'decrement': return { ...state, count: state.count - 1 };
    default: return state;
  }
};
const initialState = { count: 0 };
const { dispatch, useStoreState } = createStore(reducer, initialState);

const Counter = () => {
  const value = useStoreState('count');
  return (
    <div>
      <span>Counter: {value}</span>
      <button onClick={() => dispatch({ type: 'increment' })}>+1</button>
      <button onClick={() => dispatch({ type: 'decrement' })}>-1</button>
    </div>
  );
};

const App = () => (
  <>
    <Counter />
    <Counter />
  </>
);

API

createGlobalState

Create a global state.

It returns a set of functions

• useGlobalState: a custom hook works like React.useState
• getGlobalState: a function to get a global state by key outside React
• setGlobalState: a function to set a global state by key outside React
• subscribe: a function that subscribes to state changes

Parameters

• initialState State

Examples

import { createGlobalState } from 'react-hooks-global-state';

const { useGlobalState } = createGlobalState({ count: 0 });

const Component = () => {
  const [count, setCount] = useGlobalState('count');
  ...
};

createStore

Create a global store.

It returns a set of functions

• useStoreState: a custom hook to read store state by key
• getState: a function to get store state by key outside React
• dispatch: a function to dispatch an action to store

A store works somewhat similarly to Redux, but not the same.

Parameters

• reducer Reducer<State, Action>
• initialState State (optional, default (reducer as any)(undefined,{type:undefined}))
• enhancer any?

Examples

import { createStore } from 'react-hooks-global-state';

const initialState = { count: 0 };
const reducer = ...;

const store = createStore(reducer, initialState);
const { useStoreState, dispatch } = store;

const Component = () => {
  const count = useStoreState('count');
  ...
};

Returns Store<State, Action>

useGlobalState

useGlobalState created by createStore is deprecated.

Type: function (stateKey: StateKey): any

Meta

• deprecated: useStoreState instead

Examples

The examples folder contains working examples. You can run one of them with

PORT=8080 npm run examples:01_minimal

and open http://localhost:8080 in your web browser.

You can also try them in codesandbox.io: 01 02 03 04 05 06 07 08 09 10 11 13

Blogs

• TypeScript-aware React hooks for global state
• An alternative to React Redux by React Hooks API (For both JavaScript and TypeScript)
• Redux middleware compatible React Hooks library for easy global state management
• React Hooks Tutorial on pure useReducer + useContext for global state like Redux and comparison with react-hooks-global-state
• Four patterns for global state with React hooks: Context or Redux
• Steps to Develop Global State for React With Hooks Without Context

Community Wiki

• Persistence
• Optional initialState

Download Details:

Author: Dai-shi
Source Code: https://github.com/dai-shi/react-hooks-global-state 
License: MIT license

#typescript #react #state #management 

How to Everything About React State Management

How to Everything About React State Management

Highlights for State Management in React

🟠 React State Management enables entrepreneurs to build an enterprise app that is scalable, maintainable, and performant.
🟠 There are different ways to effectively apply state management in React js applications: using component state, context API, react & custom hooks, render props, high-order components, and React State Management Libraries.
🟠 The state management libraries in React are pre-built code bundles that are added to the React frontend so that state management of components becomes easy.
🟠 There are various states of React components, such as local, global, fetch, UI state, server-caching, mutable, complex, etc.), and each has its essence.

Read the blog ahead for in-depth information about React State Management.

Why is State Management in React Enterprise Apps Crucial?

The most critical and challenging choice of a business owner is to build their enterprise application in such a manner that it is easy to maintain, can be reusable, delivers high performance, and the most essential is that the app must have a good scope of scalability.

React State Management is a striking topic in the web development domain, and when you have a React.js enterprise application, getting an in-depth grasp of the same is vital. As we know the pain points of business app development, let us check how state management React libraries can enable your enterprise app to match your business aims.

State Management in React enables the following:

Performance

React.js applications may have difficulty loading the frontend due to the re-renders. With React state management, you can optimize your state updates, resulting in better app performance and efficiency.

Maintenance

State management in React applications enables you to modularize and encapsulate state updates. Hence, you can easily maintain and debug your codebase. This maintainability also ensures that the new development team additions can quickly adapt and understand the applications’ states.

Reusability

It is difficult to reuse states across various components of a React application, but, using React state management libraries like Redux and MobX, you can easily share states across all the components of your application.

Scalability

A poor state management strategy leads to performance degradation and bugs, making it difficult to manage the states as the applications scale in size and complexity. React provides a well-designed state management strategy to ensure you can flawlessly scale your React js applications.

This is how State Management React is the wise solution for CTOs and Product owners.

Different Approaches to State Management in React

As you have a React Js application offering speed, flexibility, rich UI, and so much more, you would want to leverage the state of components in your application.

Find out the different ways to attain React state management:

Component State

Each React component has its internal state, which can be 2used to store and manage data that is specific to that component. This state is managed using the setState method, which updates the component’s state and triggers a re-render.

Context API

The Context API is a built-in way to share the state between components in React without passing data down the component tree through props. This can be a useful alternative to using component state when you need to share state between components that are not directly connected in the component tree.

React Hooks

React Hooks are a way to add state and other React features to functional components. The useState and useReducer hooks can be used to manage local component state, while the useContext hook can be used to access shared state from the Context API.

Custom Hooks

Custom hooks are a way to extract state and logic into reusable functions that multiple components can use. This can be a good option for sharing state and logic between components that are not deeply nested in the component tree.

Higher-Order Components (HOCs)

Higher-Order Components are a way to share the state between components by wrapping components with another component that provides the state. This can be a good option for sharing the state between components not profoundly nested in the component tree.

Render Props

Render props is a pattern for sharing state between components by passing a function as a prop that renders the component that needs the state. This can be a good option for sharing the state between components not deeply nested in the component tree.

Besides the above, many State Management React Libraries are available for use. Let us find out more about them.

React State Management Tutorial

Let us get to a practical where we will learn how to manage states in an React application.

Objective: A simple increment/decrement application in React using the in-built state management features.

Step 1: Create a New React Project

npx create-react-app counter-app

Now, as your project is created, navigate to the src directory and create a new file called ‘counter.js’.

Step 2: Define the Main Function

First, let’s import React and create a new functional component called Counter. Inside the component, we’ll use the useState hook to create a new state variable called count and set it to an initial value of 0. We’ll also create two functions called increment and decrement that will be used to update the count variable:

import React, { useState } from 'react';

function Counter() {
  const [count, setCount] = useState(0);

  const increment = () => {
    setCount(count + 1);
  };

  const decrement = () => {
    setCount(count - 1);
  };

  return (
    <div>
      <h1>{count}</h1>
      <button onClick={increment}>+</button>
      <button onClick={decrement}>-</button>
    </div>
  );
}

export default Counter;

In the code above, we’re using the useState hook to create a new state variable called count and a function called setCount that will be used to update the count variable. We’re setting the initial value of count to 0.

We’re also creating two functions called increment and decrement that will be called when the user clicks on the “+” and “-” buttons, respectively. Inside these functions, we’re calling the setCount function to update the value of count by either adding or subtracting 1.

Finally, we’re returning a div element that contains the current value of count, as well as two buttons that call the increment and decrement functions when clicked.

Step 3: Render the ‘Counter’ in the Main JS File

Now, let’s go to App.js file and render the Counter component:

import React from 'react';
import Counter from './Counter';

function App() {
  return (
    <div>
      <Counter />
    </div>
  );
}

export default App;

You should now be able to run the app by running npm start and see the counter application in your browser.

This was a simple example of handling and managing state in React application.

14 Top React State Management Libraries

Here are the popular libraries pre-built for state management in React js applications, along with their pros and cons.

1. Redux

Redux is a popular state management library for building web applications with React, Angular, and other frameworks. It provides a centralized store to manage the state of an application and a set of rules for predictably modifying that state.

Pros: Predictable state management, debuggable, robust ecosystem, time-travel debugging, and efficient handling of complex state changes.

Cons: Can be complex to set up and configure, dependency on boilerplate code, not suitable for simple apps, and requires an understanding of functional programming concepts.

2. MobX

MobX is a react state management library that uses observables to track state changes and automatically re-render components when those observables change.

Pros: Simple and intuitive to use, minimal boilerplate, fast and efficient, excellent performance, and has strong compatibility with React.

Cons: Lacks some features of more complex state management libraries, can be harder to debug, and has a smaller ecosystem.

3. Recoil

Recoil is a state management library for React applications that was developed by Facebook. It provides a centralized store to manage the state of an application and a set of hooks for accessing and updating that state.

Pros: Simple, flexible, easy to learn and use, and outstanding performance.

Cons: A relatively new library, which is under development, and the community is not mature, but growing.

4. Jotai

Jotai, by Pedro Nauck, uses atoms and setters to manage the state of an application, focusing on simplicity and performance.

Pros: Simple and lightweight, easy to use, works well with React, and has a small learning curve.

Cons: A relatively new library, still under active development, and the ecosystem is not as mature as other libraries.

5. Zustand

Guillaume Salva gave the Zustand state management library for React, which uses a simplified Redux-like approach to manage the state of an application.

Pros: Simple and easy to use, with minimal boilerplate code, drives performance and has a small bundle size.

Cons: Not suggested for complex state management handling, and the ecosystem is still growing.

6. Rematch

Shawn McKay built this Redux-based state management library for React applications. It provides a simplified API for creating Redux stores and reducers, such that it reduces the dependency on boilerplate and improves developer productivity.

Pros: Easy to use and understand, using lesser boilerplate code than traditional Redux, and provides excellent performance.

Cons: Still requires a good understanding of Redux concepts, may not be suitable for large-scale projects, and has a smaller ecosystem than other options.

7. Hookstate

Hookstate is a relatively new state management library for React applications that was developed by Rafael Wieland. At its core, Hookstate uses a simplified approach to manage the state of an application, emphasizing performance and developer productivity.

Pros: Simple and easy to use, minimal boilerplate, and delivers high performance.

Cons: Can use for simple state management scenarios only, and has a smaller ecosystem.

8. Valtio

Poimandres came up with the Valtio state management library that uses a minimalistic and reactive approach to manage the state of an application, with a focus on performance and developer productivity.

Pros: Simple and easy to use, minimal boilerplate, and excellent performance.

Cons: Can only be used for simple state management scenarios, and has a smaller ecosystem than other options.

9. XState

David Khourshid developed the XState library, which uses the concept of finite state machines to manage the state of an application, focusing on predictability, modularity, and testability.

Pros: Excellent for managing complex state transitions, with a strong focus on declarative programming and strong typing.

Cons: May require more time to learn and understand and may not be suitable for simpler state management scenarios.

10. Unstated

Unstated is a lightweight state management library that uses the React context API to share state between components. It is a simpler alternative to Redux and MobX that can be used for smaller or simpler applications.

Pros: Simple and easy to use, with minimal boilerplate and good performance.

Cons: Not advisable for large-scale projects, and can have potential performance issues as it is dependent on Context API in React, which is slow in certain situations. Has a limited ecosystem and a long learning curve.

11. React-router

Ryan Florence and Michael Jackson developed this library for routing in React apps. React Router provides a declarative way to handle routing in a React application, focusing on simplicity, flexibility, and performance.

Pros: Powerful and flexible routing options and a large ecosystem.

Cons: Can be complex to set up and configure, and can lead to performance issues in some cases.

12. React-stately

Adobe developed the React-stately state management library, which at its core, provides a set of hooks and components that can be used to manage complex UI states, such as those found in form inputs, dropdowns, and menus.

Pros: Designed specifically for creating accessible user interfaces with good performance and a clean, composable API.

Cons: Not suitable for more complex state management scenarios.

13. React-powerhooks

Fabien Juif developed this library of reusable hooks for React applications. At its core, React Powerhooks provides a set of hooks that manage common UI states, such as loading, error handling, and form validation.

Pros: Provides a variety of useful hooks for common scenarios. These hooks require minimum setup.

Cons: Not suitable for more complex state management scenarios.

14. react-use-state-updater

Jed Watson developed this library that provides a hook to manage the state of a React component, with a focus on performance and developer productivity.

Pros: Improves the performance of React components that rely heavily on useState.

Cons: Only suitable for some use cases. It is less intuitive to use than the built-in useState hook.

All about ReactJs States

By far, we learned, understood, and discussed the states of components in ReactJs applications and how to handle and manage State Management in React. Let us now get to the core basics.

Here are the different states of React components:

Local State

The local state is specific to a single component and is managed using the setState method. It is typically used to stores component-specific data and is only used within that component.

Global State

The global state is shared between multiple components and manages the entire application’s global data. It is typically stored in a centralized store, such as a Redux store, an `d accessed by components through the store’s state.

Fetch State

This state is used to manage the data fetched from a remote server or API. The Fetch state is typically used to store information about the state of a fetch operation, such as whether the data has been loaded, if there was an error, or if the data is being loaded.

UI State

Manages the data that affects how the UI is displayed- data related to the user interface. Examples of UI state include whether a form is visible or a modal is open, the current selected tab, or the current scroll position.

Server-side Caching State

Stores the state on the server and is used to cache data for performance optimization. Server-side caching state is typically used to store data that does not change frequently, such as information about products or user profiles, to reduce the number of round trips to the server.

Mutable State

It refers to data that can change over time and is typically stored in the component state using the useState hook or in a class component’s state. The mutable state can be simple, such as a string or number, or more complex, such as an array or object. When the state updates, React will re-render the component and any child components that depend on that state.

Complex State

Refers to data derived from other data and is typically not directly mutable. Instead of being stored in a state, a complex state is calculated using the component’s props or other state variables. Examples of this include the results of a calculation, the filtered or sorted version of an array, or the current state of an animation. Because the complex state is not directly mutable, it doesn’t trigger re-renders of the component when it changes.

Conclusion

React state management is the most essential decision for entrepreneurs to build scalable, performant, and robust React applications. It ensures that our app remains in sync with the user interface. We saw the various in-built as well as third-party options to handle and manage states in React application. From the wide range of solutions, your choice depends on your project requirements, as well as the size of your development team.

Original article source at: https://www.bacancytechnology.com/

#react #state #management 

Guide to SLEs & SLAs for Open Source Projects

Guide to SLEs & SLAs for Open Source Projects

Setting Service Level Expectations can help a project function successfully when there's no binding contract.

The term Service Level Agreement (SLA) is a familiar one, particularly in the context of a cloud or managed service on the web. An SLA refers to the contractual obligations a service provider has to its customers and is the instrument defining permissible performance levels for the service. For example, a service agreement might determine a service level of 99.95% uptime, with penalties for falling under 99.95% uptime (more than about 4.5 hours of downtime in a year or 1.125 hours per quarter).

The term is so useful for describing both requirements and expectations around service uptime that it has been co-opted for other uses where a contractual agreement doesn't or can't exist. For example, a community SLA or free-tier SLA might describe a non-contractual situation with the desire or expectation of maintaining a certain service level.

The problem with this usage is a wonky but important one. In an SLA, "agreement" always means a contract; the contextual meaning of the word cannot be translated to other contexts. The relationship between two or more people is, by nature, non-contractual. That's why contracts were invented: to provide a way to formalize an agreement and its terms beyond the moment of coming to an agreement.

Misusing the term SLA creates specific problems in at least two areas:

1. In cloud-native site/system reliability engineering (SRE), two of the tools central to the practice are the Service Level Objectives (SLO), created to make sure user experiences are within an acceptable range, and the Service Level Indicator (SLI) used to track the status and trends of the SLO. Both of these roll up to an SLA in a commercial situation, but there's no good equivalent to roll up to in a non-commercial situation.
    
2. In some cases, managed cloud services are delivered to a user base, but there isn't a contractual dynamic, for example, with IT services in academic settings and open source services delivered as part of an open source project. The groups need a way to frame and discuss service levels without a contractual element.

This bit of word-wonkiness and nerdery is important to my work on the Operate First project, because part of our work is creating the first all open source SRE practice. This includes not only having SLOs/SLIs but also documenting how to write them. We do this because Operate First is an upstream open source project where the content will likely be adopted for use in a commercial context with an SLA.

As the community architect for the Operate First project, I am advocating for adopting the similar, well-used term Service Level Expectation (SLE) as the top-level object that we roll Service Level Objectives (SLOs) up to. This term reflects the nature of open source communities. An open source community does not produce its work due to a contractual agreement between community members. Rather, the community is held together by mutual interest and shared expectations around getting work done.

Put another way, if a team in an open source project does not finish a component that another team relies on, there is no SLA stating that Team A owes monetary compensation to Team B. The same is true for services operated by an open source project: No one expects an SLA-bound, commercial level of service. Community members and the wider user base expect teams to clearly articulate what they can and cannot do and generally stick to that.

I will share my proposal that a set of SLOs can be constructed to remain intact when moving from an SLE environment to an SLA environment. In other words, the carefully constructed SLIs that underlie the SLOs would remain intact going from a community cloud to a commercial cloud.

But first, some additional background about the origin and use of SLEs.

SLEs in the real world

Two common places where SLEs are implemented are in university/research environments and as part of a Kanban workflow. The concluding section below contains a list of example organizations using remarkably similar SLEs, including institutions like the University of Michigan, Washington University in St. Louis, and others. In a Kanban workflow, an SLE defines the expectations between teams when there are dependencies on each other's work. When one team needs another team to complete its work by a certain deadline or respond to a request within a specific time period, they can use an SLE that is added to the Kanban logic.

In these situations, there may be time and response information provided or understood from a related context. Staff sysadmins might be on duty in two shifts from 8AM to 8PM, for example, five days a week. The published expectation would be 5x12 for non-critical issues, with some other expectation in place for the critical, all-services-and-network-disrupted type of outages.

In an open source project, developers may be balancing time working on developing their product with supporting the product services. A team might offer to clear the issue and bug queue after lunch Monday through Thursday. So the SLE would be 4x4 for non-critical situations.

What are cold-swappable SLOs?

The core idea here is to design a set of SLOs that can be moved from under an SLE to an SLA without changing anything else.

An SLE has a focus of expectation, which can be thought of generally as ranging from low-expectation to high-expectation environments. Thus, the act of writing an SLO/SLI combo to work with an SLE environment helps to document the knowledge of how to range the measurement on the indicator for this service depending on how it's used, setup, and so on.

1. Establish an SLE with details for different services (if they have different uptime goals) and clarify boundaries, such as, "Developer teams respond to outages during an established window of time during the work week."
    
2. Developers and operators establish one to three SLOs for a service, for example, "Uptime with 5x5 response time for trouble tickets," meaning Monday-Friday from 12:00 to 17:00 UTC (5x5).
    
3. SLIs are created to track the objective. When writing the spec for the SLI, write for the specific and the generic case as much as possible. The goal is to give the reader a high percentage of what they need to implement the pattern in their environment with this software.

8 examples of SLEs

Although not in universal usage, I found many examples of SLEs in academic and research settings, an open source community example (Fedora and CentOS communities), and a very similar concept in Kanban of the expectations for seeing a sprint through from start to finish.

I'll conclude this article with a non-exhaustive list of the introductory content from each page:

University of Michigan ITS general SLEs:

The general campus Service Level Expectation (SLE) sets customer expectations for how one receives ITS services. The SLE reflects the way Information and Technology Services (ITS) does business today. This SLE describes response times for incidents and requests, prioritization of work, and the outage notification process.

Specific services may have additional levels of commitment and will be defined separately under a service-based SLE.

Washington University in St. Louis (2016) SLEs for basic IT services for all customers:

This document represents the Service Level Expectation (SLE) for the Washington University Information Technology (WashU IT) Basic Information Technology (BIT) Bundle Service.

The purpose of this agreement is to ensure that this service meets customer expectations and to define the roles/responsibilities of each party. The SLE outlines the following:

• Service Overview
• Service Features (included & excluded)
• Service Warranty
• Service Roles & Responsibilities
• Service Reporting & Metrics
• Service Review, Bundles & Pricing

Each section provides service and support details specific to the BIT Bundle Service as well as outlining WashU IT's general support model for all services and systems.

Rutgers (2019) SLE for virtual infrastructure hosting:

Thank you for partnering with us to help deliver IT services to the university community. This document is intended to set expectations about the service Enterprise Infrastructure Systems Engineering delivers as well as how to handle exceptions to that service.

Western Michigan University SLEs:

This Service Level Expectation document is intended to define the following:

• A high-level description of services provided by the Technology Help Desk.
• The responsibilities of the Technology Help Desk.
• When and how to contact the Technology Help Desk.
• The incident/work order process and guidelines.

The content of this document is subject to modifications in response to changes in technology services/support needs and will remain in effect until revised or terminated.

University of Waterloo SLEs for core services:

The purpose of this document is to define the services applicable, and provide other information, either directly, or as references to public web pages or other documents, as are required for the effective interpretation and implementation of these service level expectations.

University of Florida Research Computing SLEs:

This page describes the service level expectations that researchers should keep in mind when storing data and working on the HiPerGator system.

There are three categories of service to be considered. Please read these service descriptions carefully.

The Fedora and CentOS Community Platform Engineering (CPE) SLEs for community services:

The CPE team does not have any formal agreement or contract regarding the availability of its different services. However, we do try our best to keep services running, and as a result, you can have some expectations as to what we will do to this extent.

Kanban:

SLEs can be defined as forecasts of cycle time targets for when a given service should be delivered to a customer (internal or external)...

Service Level Expectations represent the maximum agreed time that your work items should spend in a given process. The idea is to track whether your team is meeting their SLEs and continuously improve based on analyzing past cycle time data.

Original article source at: https://opensource.com/

#opensource #service #community #management 

Best 21 Effective Team Management Skills

The number of teams or departments can be very high in large corporations. Except for small firms with only a handful of people, all other organisations have different teams working on different tasks. It is better to work in separate teams than everyone working under the same manager. Teams help get tasks completed more easily and efficiently. But every team must also have a leader capable of managing them and completing work. A set of team management skills help these managers keep the members together and achieve the team’s goals

You will learn a lot about team management and the skills needed for it in the Executive Development Programme In General Management. All the details about this course are available on our website. 

What Is Team Management?

Before looking at team management skills, we must first understand the task and why it is very important. Team management is a set of activities and strategies executed by the team’s leader to get work done by a group of people and achieve a common goal. Teams are important in a company because it helps foster good relationships and communication between employees. When working in a team, people learn from each other and improve themselves in many respects. Team leaders motivate the members to put in their best efforts.

As the members come from different backgrounds, there can be a lack of communication between them. Team management is required to take care of this and ensure that everyone understands their jobs and how they must cooperate with others. Another task of managers is ensuring that people work together without conflicts. When there are a group of employees, there is bound to be a difference of opinion, and the leaders must use their team management skills to resolve them. Good leadership helps to improve the productivity of the team. 

Importance Of Team Management

Keeps Employees Happy

Happy employees are essential for every organisation as they contribute better to the company’s overall growth. Employees must feel good about what they do because it positively affects the firm’s success. Employee retention levels will also increase when the team members feel good about working for the company. It is very important as recruitment is expensive and time-consuming. Establishments that have happy workers give better service to their customers. It will help get more loyal customers and consequently more business. Learning team management skills helps managers keep workers happy. 

Improves Productivity

Good team management helps to improve the productivity of employees. It is essential if the company must achieve its business goals and move towards better growth. Good managers create an environment that helps workers focus on the common goal instead of worrying about external problems. One of the team management skills that leaders must possess to improve productivity is maintaining personal relationships with every team member. They must also show appreciation and excitement at the team’s progress. Leaders must also openly discuss the company’s higher goals with the employees to improve interest in their job. 

Reduces Employee Turnover

Another important function of team management is to retain people. Hiring is an expensive process, and companies want to reduce this as much as possible. An important reason people leave an organisation is the poor relationship between the team and its leaders. Good team management skills will certainly help improve this relationship and keep the employees happy in their jobs. Good relationships will also help employees speak openly about their problems and seek solutions. When people trust their leaders, they will likely stay in the company for longer. 

Enrolling with the Executive Development Programme In General Management helps you learn the importance of team management. You can also learn all the skills needed for the job in this course. Please visit our website to know more details about this programme. 

Skills Needed For Team Management

• Getting The Best Out Of Members

As a team leader, it is not just the work you are responsible for. You must ensure that the whole team performs to their best capabilities. For this, it is necessary to ensure that every member uses their full potential and contributes to the team’s success. For this, you must sit and listen to their ideas. It will help you evaluate the abilities of each employee in the team. The team leader also has to make individual development plans for them. Bringing out the best in workers is one of the important team management skills.

• Giving Feedback

Not everyone knows what they are good at. Team leaders must assess each team member’s performance and give them constructive feedback. Giving positive feedback will motivate the person to do better. But team managers must also give negative feedback when someone performs below the desired level. One of the team management skills you must learn is to convey negative feedback without hurting the person. It is best to say what went wrong instead of telling them they did something wrong. 

• Delegating Effectively

One of the jobs of the team leader is to get work done by the employees. Delegation is good for the leader as well as the employees. The employees learn new tasks, and managers expand their capabilities through the team. Another important benefit of delegating work is that employees feel that you trust them with crucial jobs. The effective way to delegate work is to make them understand the value of the task and how it will impact the company’s growth.

• Interacting With Different People

Team members can avoid others who they may not like. But a team manager must interact with everyone in the team even if some people rub them the wrong way. One of the ways to do this successfully is to avoid discussing the differences and stress the common aspects. You must also listen to them and understand their feelings. It is one of the important team management skills that will help you get work done by the staff members.

• Understanding Different Workstyles

Not everyone works in the same manner. Even the time of the days when people are most productive differs from person to person. It means that the team leader must know every member’s work style and preferences. They must assign work that will make the employee excited. Observing the workers keenly is one way to understand their workstyles and preferences. It helps get the best out of everyone. 

• Resolve Problems Proactively

There can be problems in every work. It is all the more true when a team works towards the same goal. Everyone may think it is the other person’s responsibility to discuss the problem and find a solution. Detecting these problems before they assume huge proportions is one of the team management skills that every leader must possess. Talking individually to team members can help discover problems early. 

• Conflict Resolution

When people from different backgrounds work together, conflicts are possible. Unless these are resolved, the team will not achieve the goal it should. It is not good avoiding the issue. Team managers must admit the problem and do their best to resolve it. The best way is to allow all members to voice their opinions and find a middle ground that is acceptable to all. You must ensure that everyone is agreeable to the solution. 

Also  Read: Different Types of Change Management: A Complete Guide

• Serving Before Leading

Being a servant before showing yourself as a leader gets better employee engagement. Your team members start respecting and trusting you. One way to do this is to be humble and give credit to the team for any good work. You must also be transparent and tell the employees your plans so that nothing comes as a surprise. Offer career development plans to the subordinates to enable their growth in the organisation. 

• Unite The Members

One of the most critical team management skills is to keep the team united. If everyone interacts well with others, your work as a leader is very easy. Moreover, work will also get done as you want. One of the tricks to do this is to hold team-building activities regularly. Pairing new employees with experienced ones will quickly make them feel at home. You can also conduct brainstorming sessions, so everyone understands the others’ communication styles. 

• Being Approachable

If you want your team to talk to you freely about work problems or even their issues, then you must be approachable to them. If you develop this quality, it is easy for you to get information from the team. One of the ways is to get out of your office and greet the employees at their workstations. Be an active listener to any problem that your team members bring to you, however small it may be. This quality will also help you know about issues before they become unmanageable. 

• Represent The Team

It is not enough to lead the team. You must develop the capability of talking to others about your team. When employees want something to be conveyed to the top management, you must become their spokesperson. You must also regularly talk about the team’s good work to your bosses. When someone expresses a good idea, make sure to share it in the company’s internal network. This is one of the team management skills that will earn you the great trust of the team. You must also actively advocate for promotions and salary hikes for your team members. 

• Take Inputs

Another skill that every team manager must acquire is the ability to accept input from the team. It doesn’t need to be the leader who gives out instructions and suggestions always. There are many occasions when employees come out with an excellent idea. Take this input and try it honestly. If it works, give due credit to the person who came up with the solution. You don’t need to wait for them to come up with ideas. You can actively seek their opinions on various matters. 

• Deal With Unpleasant Comments

Your team may love and respect you a lot, but it is possible that, in certain circumstances, someone will make an adverse comment about you. One of the team management skills that you must certainly acquire is the patience to deal with such talk. You must not take it emotionally and see the reason behind such comments. Address the root cause instead of taking the comment personally. 

• Prevent Burnouts

It always happens that some people in the team have too much work leading to burnout. It is not good to have exhausted employees before the task is completed. Regularly check the workload that every employee has and ensure that the tasks are distributed evenly among the members. If there are less skilled people to handle certain tasks, make sure to train others and remove some burden from those handling the job. 

• Establish The Norms

Even when you are friendly and open with the team, you must also be firm in establishing and implementing team norms. The team must know the spoken and unspoken regulations that guide them. Your team must have a norm that regulates workplace interactions, and these must be established early on so that everyone doesn’t follow different rules. While developing your team management skills, make sure to learn the ability to enforce norms in the group.

• Motivate The Team

There are two ways to motivate your team. One is by way of recognition and rewards, and the other by making them feel satisfied in their work. Instilling a sense of satisfaction in your workers is difficult but pays more than rewards. If you can make them feel happy in completing their jobs successfully, they will find the problems for various solutions. They will also come up with ideas to finish work more efficiently and quickly. 

• Recognise And Reward

Everyone wants their work to be recognised. They also expect to get rewards for good work. As a team manager, you must ensure that you recognise and appreciate the work done by your team members. It is quite important to make sure that everyone, including your team members and the top management, knows about your employees’ achievements. This is one of the important team management skills that will help you get the best out of your staff members. 

• Emotional Intelligence

As a team manager, you deal with people with different personal and professional problems. You must help them get over it with a lot of empathy. Emotional intelligence is one of the pivotal team management skills that help you deal with situations with dignity and grace. This skill is defined as the ability to correctly understand expressions of feelings and respond to them in the right way. This skill helps you connect with employees and earn their trust very quickly. 

• Organising Skills

Remaining organised is crucial for all team managers. There will be so many activities going on in your department that it is easy to forget something. When you are organised well, you can check with your team members to make sure that all the tasks are completed without any delay. Being organised also helps you present any report to the top management whenever asked for. When you are organised, you can think clearly and find solutions to any problem. This gives confidence to your team members. 

• Decision Making

It is one of the obvious team management skills that every manager must possess. There are various occasions when you need to make quick decisions. If you can make those decisions, you can get the task completed without any delay. The ability to make decisions correctly also earns the respect of your subordinates. You can also help them make decisions when there are tough situations. When you help them in such circumstances, they will put in their best efforts to achieve the team’s goals. 

• Technical Proficiency

Whether you need technical knowledge in your job or not, it is best to be familiar with all modern technology. Various tools are available for completing your job and keeping track of others’ tasks. Such tools help you save a lot of time and give you the space to think of innovative solutions. Tracking the tasks of your staff members also ensures that no job is left unattended. It will also help you present the status of your project at any time to your bosses. 

All these skills are taught in the Executive Development Programme In General Management offered by prestigious institutions. You can learn about such courses on our website. 

Conclusion

Being able to manage a team well and getting your work completed successfully not only gives you satisfaction but also elevates you in front of the top management. It is one way of making sure that you progress quickly in your career and achieve your professional goals. But team management is not an easy task. This has been made tougher with the introduction of remote members to the team. But with the right skills and the correct tools, you can do the job well. Attending a good course is one way to ensure that you are successful as a manager. 

Original article source at: https://www.edureka.co/

#management #skills #effective 

Use The Arch Linux Network Manager

The Arch Linux system network service known as “Arch Linux Network Manager” controls the network connections for the Arch Linux operating system. It can toggle between various connections, handle both wired and wireless connections, and instantly connect to the established networks. Additionally, it could be employed to set up the network configurations such as IP addresses, DNS servers, and routing. With the help of the Network Manager, users can control their networks more effectively and easily. In this guide, we will discuss how an Arch Linux user can use the Network Manager on its system after configuring it.

Install the Network Manager

Before managing the network properties for your Arch Linux system, you should have a Network Manager installed at your end. For this, we cast off the pacman utility of Arch Linux to install the Network Manager followed by its “-S” option. The following command is used to install three software packages on an Arch Linux system using pacman.

The wpa_supplicant is used to authenticate a user on a wireless network and provides the essential encryption keys. The wireless_tools allows you to configure the wireless interfaces such as setting the SSID, the channel, and the encryption method. Last but not the least, the Network Manager is a system network service that copes with network connections on the Arch Linux operating system. It allows you to use both wired and wireless connections and can automatically associate with identified networks and switch among numerous connections.

[omar@omar ~]$ sudo pacman -S wpa_supplicant wireless_tools networkmanager

Any mobile device can have a network manager configured in the same way. The following command is used to install three software packages on an Arch Linux system using the pacman package manager. The “modemmanager” is a DBus-activated daemon that controls the mobile broadband (2G/3G/4G) devices and connections. The mobile-broadband-provider-info is a package that contains a database of the mobile broadband providers. The usb_modeswitch is a program that enables the mode switching of various USB devices that have multiple modes of operation.

[omar@omar ~]$ sudo pacman -S modemmanager mobile-broadband-provider-info usb_modeswitch

The “rp-pppoe” is a PPP over Ethernet client for Linux. It permits you to associate with a PPPoE (Point-to-Point Protocol over Ethernet) server which is usually used by the DSL suppliers to deliver an Internet access to customers. The package delivers the pppoe-connect and pppoe-start instructions command-line utility which can be used to create and control the PPPoE connections. The “sudo pacman -S rp-pppoe” command is used to install the rp-pppoe package on an Arch Linux system using the pacman package manager. Once the installation is finished, you will see an output like this:

[omar@omar ~]$ sudo pacman -S rp-pppoe

In Arch Linux, the nm-connection-editor and network-manager-applet are the tools that allow the users to easily manage and configure their network connections on a Linux system. They provide a graphical user interface that makes it simple to set up and edit the network connections including wired and wireless connections. Additionally, nm-connection-editor and network-manager-applet can help the users to easily switch between different connections depending on their location or needs. Therefore, we tried the following command to install them. The command starts by resolving the dependencies and checking for conflicting packages. The user is then asked to confirm the installation before the packages are downloaded and installed.

[omar@omar ~]$ sudo pacman -S nm-connection-editor network-manager-applet

Configure the Network Manager

It’s time to configure the network manager on our Arch Linux with the help of simple instructions. This systemctl command enables the NetworkManager service. The command creates symbolic links in the /etc/systemd/system/ directory for the NetworkManager service, the NetworkManager-dispatcher service, and the NetworkManager-wait-online service. These links are used to start the service automatically when the system starts up and ensures that the service is running at all times.

[omar@omar ~]$ sudo systemctl enable NetworkManager.service

We disable the default dhcp service. The following command removes the symbolic link in the /etc/systemd/system/multi-user.target.wants/ directory for the dhcpcd service. This ensures that the service does not start automatically when the system starts up and that it does not run at all times. This can be useful if you want to use a different DHCP client or configure the network settings manually.

[omar@omar ~]$ sudo systemctl disable dhcpcd.service

The wpa_supplicant is a supportive service that is responsible to connect to the wireless networks and manage the wireless connections. The “systemctl” command creates the symbolic links that are used to start the service automatically when the system starts up and ensures that the service is running at all times.

[omar@omar ~]$ sudo systemctl enable wpa_supplicant.service

It’s time to start the Network Manager service on Arch Linux using the systemctl command that is shown in the following. This command starts the NetworkManager service, allowing it to manage and configure the network connections on the system. This command is useful if the service is previously stopped or if you want to start the service after a reboot or disable it temporarily.

[omar@omar ~]$ sudo systemctl start NetworkManager.service

The “nmcli” command is used to list the available wifi networks. The command lists every wifi network that is accessible to your device. Since we are working on the virtual box with an ethernet connection, it does not display any network.

[omar@omar ~]$ nmcli device wifi list

The nmcli command is cast off to connect to a wifi network using the Network Manager. The wifi’s SSID is its name, and its password is contained in the SSID-PASS> argument.

[omar@omar ~]$ nmcli device wifi connect SSID password SSID-PASS

Here is the command that shows a list of all connections, whether they are currently active or not. This can be helpful to detect which connections are currently active on the system or to resolve the network difficulties.

[omar@omar ~]$ nmcli connection show
NAME                UUID                               TYPE     DEVICE
Wired connection 1  6e94cfb0-9efc-33e0-a680-8fa732e1f852  ethernet   enp0s3

To make a connection working for your machine, use the following instruction with the UUID of a particular device.

[omar@omar ~]$ nmcli connection up uuid UUID

To reload, use the following instruction:

[omar@omar ~]$ sudo nmcli connection reload

The one-word “nmtui” command can be utilized to edit the connections through GUI and is very easy to use in comparison to the previous instructions.

[omar@omar ~]$ nmtui

Conclusion

After going through this guide, you will understand the importance of using the Network Manager on Arch Linux which allows you to manage the different internet connections, especially the wifi networks. Starting from installing the Network Manager in your device to configuring it, all the steps are very easy and simple using simple instructions. Lastly, you will be able to list all the available networks and connect with them on Arch Linux.

Original article source at: https://linuxhint.com/

#linux #network #management 

UseStateMachine: The <1 Kb State Machine Hook for React

UseStateMachine

The <1 kb state machine hook for React:

See the user-facing docs at: usestatemachine.js.org

• Batteries Included: Despite the tiny size, useStateMachine is feature complete (Entry/exit callbacks, Guarded transitions & Extended State - Context)
• Amazing TypeScript experience: Focus on automatic type inference (auto completion for both TypeScript & JavaScript users without having to manually define the typings) while giving you the option to specify and augment the types for context & events.
• Made for React: useStateMachine follow idiomatic React patterns you and your team are already familiar with. (The library itself is actually a thin wrapper around React's useReducer & useEffect.)

Examples

• State-driven UI (Hiding and showing UI Elements based on the state) - CodeSandbox - Source
• Async orchestration (Fetch data with limited retry) - CodeSandbox - Source
• Sending data with events (Form) - CodeSandbox - Source

Installation

npm install @cassiozen/usestatemachine

Sample Usage

const [state, send] = useStateMachine({
  initial: 'inactive',
  states: {
    inactive: {
      on: { TOGGLE: 'active' },
    },
    active: {
      on: { TOGGLE: 'inactive' },
      effect() {
        console.log('Just entered the Active state');
        // Same cleanup pattern as `useEffect`:
        // If you return a function, it will run when exiting the state.
        return () => console.log('Just Left the Active state');
      },
    },
  },
});

console.log(state); // { value: 'inactive', nextEvents: ['TOGGLE'] }

// Refers to the TOGGLE event name for the state we are currently in.

send('TOGGLE');

// Logs: Just entered the Active state

console.log(state); // { value: 'active', nextEvents: ['TOGGLE'] }

API

useStateMachine

const [state, send] = useStateMachine(/* State Machine Definition */);

useStateMachine takes a JavaScript object as the state machine definition. It returns an array consisting of a current machine state object and a send function to trigger transitions.

state

The machine's state consists of 4 properties: value, event, nextEvents and context.

value (string): Returns the name of the current state.

event ({type: string}; Optional): The name of the last sent event that led to this state.

nextEvents (string[]): An array with the names of available events to trigger transitions from this state.

context: The state machine extended state. See "Extended State" below.

Send events

send takes an event as argument, provided in shorthand string format (e.g. "TOGGLE") or as an event object (e.g. { type: "TOGGLE" })

If the current state accepts this event, and it is allowed (see guard), it will change the state machine state and execute effects.

You can also send additional data with your event using the object notation (e.g. { type: "UPDATE" value: 10 }). Check schema for more information about strong typing the additional data.

State Machine definition

Defining States

A finite state machine can be in only one of a finite number of states at any given time. As an application is interacted with, events cause it to change state.

States are defined with the state name as a key and an object with two possible keys: on (which events this state responds to) and effect (run arbitrary code when entering or exiting this state):

On (Events & transitions)

Describes which events this state responds to (and to which other state the machine should transition to when this event is sent):

states: {
  inactive: {
    on: {
      TOGGLE: 'active';
    }
  },
  active: {
    on: {
      TOGGLE: 'inactive';
    }
  },
},

The event definition can also use the extended, object syntax, which allows for more control over the transition (like adding guards):

on: {
  TOGGLE: {
    target: 'active',
  },
};

Guards

Guards are functions that run before actually making the state transition: If the guard returns false the transition will be denied.

const [state, send] = useStateMachine({
  initial: 'inactive',
  states: {
    inactive: {
      on: {
        TOGGLE: {
          target: 'active',
          guard({ context, event }) {
            // Return a boolean to allow or block the transition
          },
        },
      },
    },
    active: {
      on: { TOGGLE: 'inactive' },
    },
  },
});

The guard function receives an object with the current context and the event. The event parameter always uses the object format (e.g. { type: 'TOGGLE' }).

Effects (entry/exit callbacks)

Effects are triggered when the state machine enters a given state. If you return a function from your effect, it will be invoked when leaving that state (similarly to how useEffect works in React).

const [state, send] = useStateMachine({
  initial: 'active',
  states: {
    active: {
      on: { TOGGLE: 'inactive' },
      effect({ send, setContext, event, context }) {
        console.log('Just entered the Active state');
        return () => console.log('Just Left the Active state');
      },
    },
  },
});

The effect function receives an object as parameter with four keys:

• send: Takes an event as argument, provided in shorthand string format (e.g. "TOGGLE") or as an event object (e.g. { type: "TOGGLE" })
• setContext: Takes an updater function as parameter to set a new context (more on context below). Returns an object with send, so you can set the context and send an event on a single line.
• event: The event that triggered a transition to this state. (The event parameter always uses the object format (e.g. { type: 'TOGGLE' }).).
• context The context at the time the effect runs.

In this example, the state machine will always send the "RETRY" event when entering the error state:

const [state, send] = useStateMachine({
  initial: 'loading',
  states: {
    /* Other states here... */
    error: {
      on: {
        RETRY: 'load',
      },
      effect({ send }) {
        send('RETRY');
      },
    },
  },
});

Extended state (context)

Besides the finite number of states, the state machine can have extended state (known as context).

You can provide the initial context value in the state machine definition, then use the setContext function within your effects to change the context:

const [state, send] = useStateMachine({
  context: { toggleCount: 0 },
  initial: 'inactive',
  states: {
    inactive: {
      on: { TOGGLE: 'active' },
    },
    active: {
      on: { TOGGLE: 'inactive' },
      effect({ setContext }) {
        setContext(context => ({ toggleCount: context.toggleCount + 1 }));
      },
    },
  },
});

console.log(state); // { context: { toggleCount: 0 }, value: 'inactive', nextEvents: ['TOGGLE'] }

send('TOGGLE');

console.log(state); // { context: { toggleCount: 1 }, value: 'active', nextEvents: ['TOGGLE'] }

Schema: Context & Event Typing

TypeScript will automatically infer your context type; event types are generated automatically.

Still, there are situations where you might want explicit control over the context and event types: You can provide you own typing using the t whithin schema:

Typed Context example

const [state, send] = useStateMachine({
  schema: {
    context: t<{ toggleCount: number }>()
  },
  context: { toggleCount: 0 },
  initial: 'inactive',
  states: {
    inactive: {
      on: { TOGGLE: 'active' },
    },
    active: {
      on: { TOGGLE: 'inactive' },
      effect({ setContext }) {
        setContext(context => ({ toggleCount: context.toggleCount + 1 }));
      },
    },
  },
});

Typed Events

All events are type-infered by default, both in the string notation (send("UPDATE")) and the object notation (send({ type: "UPDATE"})).

If you want, though, you can augment an already typed event to include arbitrary data (which can be useful to provide values to be used inside effects or to update the context). Example:

const [machine, send] = useStateMachine({
  schema: {
    context: t<{ timeout?: number }>(),
    events: {
      PING: t<{ value: number }>()
    }
  },
  context: {timeout: undefined},
  initial: 'waiting',
  states: {
    waiting: {
      on: {
        PING: 'pinged'
      }
    },
    pinged: {
      effect({ setContext, event }) {
        setContext(c => ({ timeout: event?.value ?? 0 }));
      },
    }
  },
});

send({ type: 'PING', value: 150 })

Note that you don't need to declare all your events in the schema, only the ones you're adding arbitrary keys and values.

Wiki

• Updating from version 0.x.x to 1.0
• Contributing
• Comparison with XState
• Source code walkthrough video
• Usage with Preact

Download Details:

Author: Cassiozen
Source Code: https://github.com/cassiozen/useStateMachine 
License: MIT license

#typescript #hooks #state #management 

Facilitation Techniques in Project Management

Introduction to Facilitation in Project Management

Facilitation is indeed a fancy word in the world of Project management. The more it sounds Fancy, the more tricky it is. Facilitation means making things more manageable, and making things more accessible is a big task! The facilitator does not have any power over what is being discussed in the group; they make it easier for everyone.

Why don’t we understand what facilitation is from the very start? Facilitation is a skill to drive the best and resolve the worst in a group while working on any project with a specific objective. Project management meetings can be used as a great tool to facilitate.

As per the Scrum guide, “someone who helps a group of people understands and achieve their objectives by promoting collaboration, optimizing the process, and creating synergy within the team.” Facilitation is a process in which someone-a facilitator-helps people reach a decision or goal. The facilitator does not take over the discussion but helps the group explore ideas and find new solutions.

Facilitation is a valuable tool for project managers. It helps them to manage the complexities of projects and to keep stakeholders on track and on time.
The word "facilitate" comes from the Latin word "facilities," which means “ease, convenience, or comfort.” It refers to making something more accessible, less complex, less complicated, or more pleasant. Facilitation is managing projects by listening attentively to people's different perspectives and finding solutions that work for everyone involved. A good facilitator will create an environment where people are comfortable expressing themselves in a non-threatening way.

What are the types of Facilitation?

Facilitation manages the communication between the stakeholders to reach a shared understanding of the project. It can be done by using different techniques to guide discussions and decisions. There are two main types of facilitation:

• Informal facilitation: It is unplanned, spontaneous, and has no formal structure or preset agenda. It is used when there are few people involved in the discussion, when there are no time constraints and when participants have already agreed on what they want to achieve during the meeting.
• Formal facilitation: This type of facilitation has a more structured approach, with a preset agenda and specific techniques for guiding discussions and decisions. It is used when many people are involved in the discussion when time constraints exist.

What are the key skills of facilitator?

• The facilitator should know how to design, take the lead in meetings, and ensure meeting the objectives and goals.
• Facilitators should be able to question relevant points to get clarity over new insights.
• The facilitator must have listening skills.
• The facilitator must work on creating a powerful team instead of looking for individuals.
• Facilitator should be able to help things happen.
• The facilitator must have a keen observation.
• Facilitators should understand how to address difficult attitudes and unproductive behavior.

What are the facilitation techniques in Project Management?

The facilitation techniques in project management are described below:

Leading the group in brainstorming sessions

We must define the problem and why we have this brainstorming session. Let everyone showcase their ideas. Try to make the session more exciting and creative.

Questioning

Questioning helps to check the understanding level of the participants. It also makes everyone attentive.

Clarifying

If we have observed someone isn’t clear about things in the meeting. We need to clarify things with him so everyone can be on the same page.

Facilitating discussions

Introduce the discussion topic to everyone and maintain the flow. Summarize the meeting.

Encouraging participation from all members of the group

Encourage everyone to participate and put their viewpoints in the discussion.

Summarizing

At the end of the discussion, sum up the discussion points and actionable.

What are its best practices?

The best practices for 

Being assertive, not being aggressive.

When we are assertive there is nothing like being passive nor aggressive, direct and honest. We don't expect other people in the meeting to know what we want, so we speak up to ask for what we need with confidence.

I create a meeting agenda every time

Creating the agenda is essential since it helps other attendees know about the meeting, like what will happen. A meeting agenda also helps the guest set priorities and help to sort their schedule.  

Always set meeting ground rules

As a facilitator, setting the rules for a great meeting is crucial.

Some rules are like:-

1. What kind of meeting do we have? Should everyone be aware of this?
2. Limitation on the number of attendees, only relevant members should be invited.
3. The team must join on time.
4. Always focus on the agenda/issue, not on the people.

Always document and record decisions and action items

Making things documented is always beneficial. During meetings, there are high chances of forgetting a few points if the meetings are longer. It has been observed that recording the meeting and actionable items is a great way to track the progress. Actionable helps to understand what all actions are for whom, and as a facilitator, we can track it.

Ask leading questions

Asking the leading questions is always a step nearer to clarity. It helps to analyze the team’s understanding too. Questions such as:-

• What’s your view on the plan?
• Have we covered all the requirements?
• Are the timelines final?
• Is there anything we are not aware of?
• What do you feel about the current plan?

Conclusion

Facilitation has a lot of detailed processes since it involves people. Understanding the importance of time and keeping decorum while encountering the leading questions makes the process complex. We help people decide without taking over the discussion but instead help the group to explore ideas and find new solutions, which makes the whole process challenging as we need to pull out the best ways to fulfill the agenda of the meeting. The best practices should be followed since it helps the facilitator to align. Facilitation is the skill of managing different people with different ideas and opinions. Making sure everyone is on the same page. 

Original article source at: https://www.xenonstack.com/

#agile #delivery #management 

The Ultimate Guide: Value Stream Management Platform

Introduction to Value Stream Management Platform

Value Stream Management is a good idea for going around the DevOps community. We'll understand what it is all about and how to implement it. We know that in software delivery, we're always trying to get the best innovative ideas from the business delivered to the customer. Value Stream Management believes everything that happens, from ideas to customers, is essential and needs to be managed holistically.

Rather than managing the developers, testers, and business analysts separately, we optimize the flow of information across all these groups.

Let's look at an example:

We have an idea for a particular module and prioritize it before we go to the design /development team for implementation. Because we deliver to the client, there's a testing team, and we run a whole group of tests on them. Once the test team has verified the expected functionality, then we go for a release.

Now we want to start optimizing the above process to save the release times so that we can see the scope of improvement is likely to go every step, and that will mean certain time needs to be dedicated to every step of the way. There's likely to be waiting for time / unused resources that can be taken care off by amplifying their processes. They were able to remove the underlying inefficiencies.

What is Value Stream Management?

Value Stream Management (VSM) is a method used to visualize and optimize the flow of value in an organization. It is a systematic approach to identifying, analyzing, and improving the series of activities a product or service goes through from conception to delivery to the customer.

What is the Role of ValueOps in VSM?

Value Stream Management is a method used to visualize and optimize the flow of value in an organization. It is a systematic approach to identifying, analyzing, and improving the series of activities a product or service goes through from conception to delivery to the customer.

ValueOps puts "value" into it by providing a single, integrated platform that unifies the business and IT.

While with DevOps, teams can speed delivery and reduce risk, and they align with strategic business outcomes. This is where Value Stream Management (VSM) has become a critical requirement for enterprise-wide success.

With an effective VSM, teams can continuously add value to customers and eliminate wasted investment. Companies must stop focusing on optimizing separate tools, teams, and departments and start optimizing the flow of products and services across the entire value stream. For many organizations, this practice poses significant challenges.

ValueOps can provide solutions to address these challenges. With this solution, companies can effectively and efficiently deploy and manage VSM strategies, allowing teams to establish the necessary internal horizontal alignment. ValueOps seamlessly combines clarity planning features with advanced Agile management, all in an integrated, easy-to-use, and flexible platform.

What does a VSM Platform do?

A Value Stream Management Platform is a software tool that helps organizations to implement and manage their VSM process. It typically provides a visual representation of the value stream and enables users to track and analyze the flow of work through the various stages of the value stream. The platform may also provide features for managing and optimizing work flow, such as scheduling, capacity planning, and performance measurement.

VSM platforms can improve the efficiency and effectiveness of an organization's operations by reducing waste, improving flow, and increasing customer satisfaction. They can be applied to various industries, including manufacturing, software development, healthcare, and finance.

Steps for adopting the VSM Platform

To adopt the VSM platform in your organization, you can follow these steps:
 

1. Identify the process or value stream that you want to analyze and improve. This could be a process within a department, a cross-functional process, or the entire value stream from raw materials to delivering a product or service to the customer.
2. Identify the team responsible for conducting the VSM analysis and implementing improvements. This team should include representatives from all functions involved in the process and be led by a trained VSM facilitator.
3. Gather data on the current state of the process. This may include information on process flow, cycle times, defects, and other metrics. You can also gather data on customer requirements and expectations.
4. Create a current state map of the process. This visual represents the flow of materials and information through the process, including all steps, handoffs, and decision points.
5. Identify waste and inefficiencies in the process. Look for activities that add no value to the product or service, delays or bottlenecks, and unnecessary steps or handoffs.
   Develop a future state map that shows how the process could be improved. This may include eliminating waste, streamlining steps, reducing handoffs, and improving communication and decision-making.
6. Implement the improvements identified in the future state map. This may involve changes to the physical layout of the process, how work is organized and performed, or changes to the tools and equipment used.
7. Monitor the process to ensure that the improvements are effective and identify any additional improvement opportunities.
8. It's important to note that VSM is an iterative process, and it may take multiple rounds of analysis and improvement to optimize a value stream fully.

Reasons to adopt the VSM Platform

There are several reasons why organizations may want to adopt the VSM platform:

• Increase efficiency and reduce waste: By identifying and eliminating waste and inefficiencies in a process, organizations can increase the speed and efficiency of the process, resulting in cost savings and improved customer satisfaction.
• Improve communication and collaboration: VSM helps bring representatives from different organizational functions and levels to work together towards a common goal. This can improve communication and collaboration, leading to better decision-making and problem-solving.
• Increase agility and responsiveness: By streamlining processes and reducing waste, organizations can become more agile and responsive to changing customer needs and market conditions.
• Improve quality: Organizations can improve the quality of their products and services by identifying and eliminating defects and other sources of variability in a process.
• Foster continuous improvement: VSM encourages a culture of continuous improvement by encouraging teams to identify and eliminate waste and inefficiencies on an ongoing basis.

Which industries would benefit from VSM Platform adoption?

VSM can be applied to any industry or organization that has a process that it wants to analyze and improve. It is particularly well-suited to manufacturing and service industries, where there is a need to optimize the flow of materials and information to deliver products or services to customers. Some specific industries that may benefit from adopting the VSM platform include:

• Manufacturing: VSM can be used to analyze and improve the flow of materials and information through manufacturing processes, resulting in improved efficiency, quality, and responsiveness to changing customer needs.
• Healthcare: VSM can be used to analyze and improve the flow of patients and information through healthcare systems, resulting in improved patient outcomes and satisfaction.
• Finance: VSM can be used to analyze and improve the flow of financial transactions and information within financial organizations, resulting in improved efficiency and accuracy.
• Government: VSM can be used to analyze and improve the flow of information and services within government agencies, resulting in improved efficiency and customer satisfaction.
• Retail: VSM can be used to analyze and improve the flow of goods and information through retail organizations' supply chain and distribution networks, resulting in improved efficiency and responsiveness to changing customer needs.

What is Value Stream Delivery Platform (VSDP)?

• Integrate or provide out-of-the-box functionality for DevOps engine functionality (to build, test, analyze, integrate, provision, configure, secure, deploy, observe, recover, etc.) ) and reduce manual tool coordination.
• Enables business analysts and product owners to identify features with information gained from progress.
• Navigate and stay secure with audit logs, even with distributed teams, workloads, and infrastructure.
• Leverage multi-channel alerts on user-defined events to speed up processes and correct errors.
• Improve time to market and app availability.
• Collaborate effectively to review code, share, and streamline delivery.
•  Provides transparency at all stages of CI/CD for better tracking, governance, and compliance.

What are the benefits of adopting Value Stream Delivery Platform (VSDP)?

• Businesses need a way to scale DevOps to deliver innovation securely and quickly, and VSDP is evolving rapidly to meet the demands of increasingly complex DevOps workflows.
• The collision between the DIY toolchain and remote working has exposed the problems faced by companies in managing software development. When the job goes silent, visibility of the progress of the work in progress fades.
• Not integrating all the different development tools and environments reduce the ability to detect security issues before new features are released.
• Non-integrated tools and non-standard DevOps environments prevent collaboration. Different Agile and DevOps tools limit process improvements.
• Adopting VSDP eliminates these problems and allows you to scale. Gartner's market report shows that early adopters of VSDP are seeing exponential gains in continuous integration/delivery (CI/CD) and the ability to drive business value.

What are the future trends of VSDP?

The need for lean development and visibility in the software value stream is deeply rooted in digital transformation and the growing pressure to deliver innovation (and value) faster:

• Mass adoption of cloud computing
• Container-based architecture
• Increase use fast development

Companies need scalable solutions to remove waste from their processes to ensure a steady stream of value to customers. To achieve this, organizations need visibility into shipping processes. When they can assess work quality and process quality, they can continuously improve delivery, helping to get higher quality features into the hands of business users faster pressure for DevOps to create business value.

Conclusion

Overall, the VSM platform can help organizations to deliver better products and services to their customers more efficiently and effectively, leading to improved business performance and customer satisfaction.

Original article source at: https://www.xenonstack.com/

#devops #management #value #stream 

Test Data Management in DevOps

Overview of Test Data Management

Automated testing is an integral part of modern software delivery practices. The ability to run comprehensive unit, integration, and system tests is critical to verify that your application or service works as expected and can be safely deployed in production. Giving the tests real data is essential to ensure that your tests validate real situations. Test data is essential because all test types need this data in your test suite, including manual and automated tests. Good test data allows you to validate popular or high-value user journeys, test edge cases, reproduce errors, and simulate failures.

It is challenging to use and manage test data effectively. Over-reliance on data defined outside the test scope can make your tests fragile and increase maintenance costs. Reliance on external data sources can cause delays and affect test performance. Copying production data is risky as it may contain sensitive information. Organizations can manage their test data carefully and strategically to meet these challenges.

Current Stage of Test data management

In today's digital age, every organization is bringing high-quality applications to market at a competitive pace. Although companies have adopted Agile and DevOps methods to pursue this goal, many have over-invested in test data, which has become an obstacle in the innovation race.

The (Test Data Management)TDM market has shifted to a new set of strategies driven by an increased focus on application availability, faster market time, and lower costs. TDM is proliferating alongside other IT initiatives like DevOps and the cloud.

As the number of application projects grows, many large IT organizations realize the opportunity to achieve economies of scale by consolidating Test data management functions into a single team or department, allowing them to take advantage of Use innovative tools to generate test data and operate more efficiently than single, decentralized, and unstructured TDM pools.

How to implement Test Data Management?

Analysis by DevOps Research and Evaluation shows that successful teams approach it with the fundamentals.

Appropriate test data is available to run a fully automated test suite. Test data for automated test suites can be collected on request. Test data does not limit or restrict the groups of automated tests that can be run.

To improve it, try to meet each of these conditions in all your development teams. These methods can also positively contribute to test automation and continuous integration capabilities.

How to measure Test Data Management?

Test data is available to run a fully automated test suite. Organizations can measure this by tracking the time developers, and testers spend managing and manipulating data in test suites. They can also capture this through sensory measurements to ask teams if they have enough data for their work or if they feel it is a limitation for them.

Test data for automated test suites can be collected on request. They can measure this by the percentage of critical datasets available, how often these are accessed, and how often they are refreshed.

Test data does not limit or restrict the groups of automated tests that can be run. They can measure this by the number of automated tests that can be run without needing to obtain additional test data. They can also capture this with perception metrics to ask teams if they feel the test data limits their automated testing activities.

Strategies to improve Test Data Management

Test data automation is a comprehensive technology set that delivers complete data and compliance to parallel teams and infrastructure. This DevOps Ready Kit includes:​

• Data records and masks
• Analyze coverage
• Compare data, and generate data
• Check data duplication
• Allocate test data
• A complete subset of data
• Data virtualization

These technologies combine to create complete, compliant, and available data in parallel. However, Test Data Automation goes a step further by making these technologies reusable as required by manual and automated data requesters. In other words, test data automation helps align test data delivery with the speed, automation, and flexibility of CI/CD and DevOps processes. This ability to automate and react to changing needs automatically responds to a wide range of data requests made by teams and executives in tandem.

What are its common challenges?

• Provisioning a test environment is a slow, manual, and demanding process- Most IT organizations rely on a request processing model in which developers and testers see their requests line up behind others. Since creating a copy of test data takes a lot of time and effort, providing updated data to the test environment can take days or weeks.
• Development teams need more high-precision data-Development teams often need access to test data suitable for their purposes.
• Data mask adds friction to the release cycle - For many applications, such as those that process credit card numbers, patient records, or other sensitive information, data masking is essential to ensure regulatory compliance and protect against fraud data breaches.
• Storage costs continue to rise-  IT organizations create multiple redundant copies of test data, resulting in inefficient memory usage. To meet concurrent demand within storage capacity limits, operations teams must coordinate the availability of test data across multiple pools, applications, and releases.

What are its best practices?

• Data Delivery: Reduce test data delivery time to developers or testers.
• Data Quality: Meets high-fidelity test data requirements.
• Data security: Minimize security risks without compromising speed.
• Infrastructure costs: Reduce the cost of storing and storing test data. The following sections highlight the main criteria for evaluating the TDM method.

What are the major benefits of Test Data Management?

• Quality improvement: The test data quality affects the product's overall quality. To produce a high-quality product, you need to use high-quality test data.
• Avoid security issues: If the data is not secure, there is a risk of a data breach, which can be costly to the organization.
• Reduce data-related errors: Due to the accuracy of test data, data-related errors or false positives are significantly reduced, thus increasing the efficiency of the testing process.
• Drive agility: It is essential for delivering IT projects because it reduces test data generation time and helps reduce delivery latency and overall test execution time. This improves development and testing by allowing for faster feedback on code changes.
• Cost reduction: Test data management enables early detection of bugs in the software development process, resulting in less expensive fixes. Additionally, not having to struggle to find relevant data allows development teams to focus on creativity and drive the organization forward.

Conclusion

Managing test data can improve compliance, optimize storage spending, and improve the end-user experience. A robust test data management strategy enables organizations to efficiently meet the test data needs of their DevOps automation cycle by supporting data profiling and analysis, governance, provision, creation, and management environments and privacy.

Original article source at: https://www.xenonstack.com/

#test #data #management #devops 

Using Your Linux Terminal As A File Manager

Here are five common file management tasks you can do with nothing but the shell.

A terminal is an application that provides access to the user shell of an operating system (OS). Traditionally, the shell is the place where the user and the OS could interface directly with one another. And historically, a terminal was a physical access point, consisting of a keyboard and a readout (a printer, long ago, and later a cathode ray tube), that provided convenient access to a mainframe. Don't be fooled by this "ancient" history. The terminal is as relevant today as it was half a century ago, and in this article, I provide five common file management tasks you can do with nothing but the shell.

1. Open a terminal and look around

Today, everyone's got a computer on their desk or in their bag. The mainframe-and-terminal model is now essentially emulated through an application. Your operating system might have a unique name for it, but generically it's usually known as a "terminal" or "console".

Linux: Look for Console, Konsole, or Terminal. Regardless of the name, you can usually launch it from your application menu using the key word "terminal."

macOS: The default terminal application isn't open source and is widely considered lacking in features. Download iTerm2 to get a feature-rich, GPLv2 replacement.

Windows: PowerShell is the open source terminal application, but it uses a language and syntax all its own. For this article to be useful on Windows, you can install Cygwin which provides a POSIX environment.

Once you have your terminal application open, you can get a view of your file system using the command ls.

ls

2. Open a folder

In a graphical file manager, you open a folder by double-clicking on it. Once it's open, that folder usually dominates the window. It becomes your current location.

In a terminal, the thought process is slightly different. Instead of opening a folder, you change to a location. The end result is the same: once you change to a folder, you are "in" that folder. It becomes your current location.

For example, say you want open your Downloads folder. The command to use is cd plus the location you want to change to:

cd Downloads

To "close" a folder, you change out of that location. Taking a step out of a folder you've entered is represented by the cd command and two dots (..):

cd ..

You can practice entering a folder and then leaving again with the frequent use of ls to look around and confirm that you've changed locations:

$ cd Downloads
$ ls
cat-photo.jpg
$ cd ..
$ ls
Documents    Downloads    Music    Pictures    Videos
$ cd Documents
$ ls
zombie-apocalypse-plan-C.txt
zombie-apocalypse-plan-D.txt
$ cd ..
$ ls
Desktop  Documents   Downloads
Music    Pictures    Videos

Repeat it often until you get used to it!

The advanced level of this exercise is to navigate around your files using a mixture of dots and folder names.

Suppose you want to look in your Documents folder, and then at your Desktop. Here's the beginner-level method:

$ cd Documents
$ ls
zombie-apocalypse-plan-C.txt
zombie-apocalypse-plan-D.txt
$ cd ..
$ ls
Desktop  Documents   Downloads
Music    Pictures    Videos
$ cd Desktop
$ ls
zombie-apocalypse-plan-A.txt

There's nothing wrong with that method. It works, and if it's clear to you then use it! However, here's the intermediate method:

$ cd Documents
$ ls
zombie-apocalypse-plan-C.txt
zombie-apocalypse-plan-D.txt
$ cd ../Desktop
$ ls
zombie-apocalypse-plan-A.txt

You effectively teleported straight from your Documents folder to your Desktop folder.

There's an advanced method, of this, too, but because you know everything you need to know to deduce it, I leave it as an exercise for you. (Hint: It doesn't use cd at all.)

3. Find a file

Admit it, you sometimes misplace a file. There's a great Linux command to help you find it again, and that command is appropriately named find:

$ find $HOME -iname "*holiday*"
/home/tux/Pictures/holiday-photos
/home/tux/Pictures/holiday-photos/winter-holiday.jpeg

A few points:

The find command requires you to tell it where to look.

Casting a wide net is usually best (if you knew where to look, you probably wouldn't have to use find), so I use $HOME to tell find to look through my personal data as opposed to system files.

The -iname option tells find to search for a file by name, ignoring capitalization.

Finally, the "*holiday*" argument tells find that the word "holiday" appears somewhere in the filename. The * characters are wildcards, so find locates any filename containing "holiday", whether "holiday" appears at the beginning, middle, or end of the filename.

The output of the find command is the location of the file or folder you're looking for. You can change to a folder using the cd command:

$ cd /home/tux/Pictures/holiday-photos
$ ls
winter-holiday.jpeg

You can't cd to a file, though:

$ cd /home/tux/Pictures/holiday-photos/winter-holiday.jpeg
cd: Not a directory

4. Open a file

If you've got a file you want to open from a terminal, use the xdg-open command:

$ xdg-open /home/tux/Pictures/holiday-photos/winter-holiday.jpeg

Alternatively, you can open a file in a specific application:

$ kate /home/tux/Desktop/zombie-apocalypse-plan-A.txt

5. Copy or move a file or folder

The cp command copies and the mv file moves. You can copy or move a file by providing the current location of the file, followed by its intended destination.

For instance, here's how to move a file from your Documents folder to its parent directory:

$ cd Documents
$ ls
zombie-apocalypse-plan-C.txt
zombie-apocalypse-plan-D.txt
$ mv zombie-apocalypse-plan-C.txt ..
$ cd ..
$ ls
Documents  Downloads    Music    Pictures
Videos     zombie-apocalypse-plan-C.txt

While moving or copying, you can also rename it. Here's how to move a file called example.txt out of the directory with the new name old-example.txt:

$ mv example.txt ../old-example.txt

You don't actually have to move a file from one directory to another just to rename it:

$ mv example.txt old-example.txt

Linux terminal for files

The Linux desktop has a lot of file managers available to it. There are simple ones, network-transparent ones, and dual-panel ones. There are ones written for GTK, Qt, ncurses, and Swing. Big ones, small ones, and so on. But you can't talk about Linux file managers without talking about the one that's been there from the beginning: the terminal.

The terminal is a powerful tool, and it takes practice to get good at it. When I was learning the terminal, I used it for what I could, and then I opened a graphical file manager for advanced operations that I hadn't learned for the terminal yet. If you're interested in learning the how to use a terminal, there's no time like the present, so get started today!

Original article source at: https://opensource.com/

#linux #management 

AI in Requirement Management

Introduction to AI in Requirement Management

Requirement management in project/product management is crucial since it helps to align towards the goal. Now the point is, Is information crucial in terms of it?

Daniel Keys Moran said “you can have data without information but you can not have information without data ”. I would like to add one powerful word “Correct” which is what matters the most otherwise false or wrong data is just worthless.

It needs “Correct Information” and strong data management. AI has turned into a game changer when it comes to it.

A requirement is any condition that must be fulfilled to satisfy a need or goal, and it is usually expressed as a statement of what needs to be done, or what is necessary for an objective to be achieved. Requirements management software helps in managing these requirements by providing tools for collaboration, tracking, and reporting.

Software that helps in the management of requirements is called requirements management software. It is an important process in software development. It helps to ensure that the right product is being developed and it also ensures that the product will meet customer needs. Artificial Intelligence can be used to automate this process and help with decision-making.

AI can be trained to understand requirements, identify missing information, flag risks, and more. Some companies are already using AI for this purpose. The benefits of using Artificial Intelligence in it include increased accuracy and speed of the process, improved quality of the requirements, reduced human error, better understanding by stakeholders about how the system will work, reduced costs associated with managing requirements manually. Requirements managers are experts in a particular domain and they use this software to manage the requirements of a business.

What are the benefits of AI in Requirement Management?

There are several benefits of Artificial Intelligence in it. One of the most important is that it can reduce the amount of time required to complete project tasks by up to 50%.

AI-based tools can automate many tasks and save a lot of time. It also helps with data accuracy and consistency.

• It helps to Automate the process which reduces time and increases effectiveness.
• Artificial Intelligence can help to deal with complexity which helps to increase visibility.
• Quality is also one of the important factors AI has improvised.
• Reduces Data redundancy which helps to bring out the correct information.
• Correct information helps to reduce the errors and it directly affects the costing in a positive way.

What are the limitation of it?

Nothing is perfect, everything has pros and cons respectively use of AI in requirement management has some cons too.

The more strong and accurate our model the more efficient it is but not every time it works. There are many model/ AI solution tools which is still under development and as this technology is in the initial stage of booming it requires a lot of time and efforts to totally rely on.

Artificial intelligence is still a new technology and however we all have seen how useful Artificial intelligence is in it.

Some of the limitations can be like the followings:-

• Less resources at present since many model are yet to be developed.
• Need more strong model since relying on the wrong model can affect the project very badly.
• Sound technical knowledge is required from the Project/ Product/ Program managers and business analysts.
• Need surveillance of the model to be in the safer side and it will help to find the issues in model or if we need to modify the model.

What are the processes for AI in Requirement Management?

Process of Artificial Intelligence in it is a process of gathering requirements, analysing them, and then implementing them. The process starts with the gathering of requirements. This is the most important part because this will determine how the rest of the process will take place. 
Gathering requirements involves few steps :-

The first step is to understand the what customer want:-

• Interviewing stakeholders, customers and other people who are knowledgeable about the product or service to identify all their needs.

The second step is analysing these requirements.

• This step entails figuring out what can be done to meet these needs and which ones are achievable.

The third step in requirement management

• Implementing these requirements and following up on them to ensure that they were met successfully.

Importance of Quality in Requirement Management

Quality is an essential part of the business. It is about getting the right product or service to the customer at the right time and at a price that they are willing to pay. Quality is not just about how well something functions, but also how well it meets customer expectations.

Quality requirements are a set of standards for quality which can be defined by various stakeholders in a company, including customers, employees, vendors and even suppliers.

The quality requirement may be based on different factors like:

• Product quality
• Service quality (i.e., delivery and execution)
• Customer service quality
• Financial performance
• Operational efficiency

Leveraging AI for Better Requirements Mapping

Construction requirements are a vital part of any project, and they must be mapped out in detail. This includes not just the materials and equipment needed, but also the skill sets required for each task.

The traditional way to map these requirements is time-intensive and error-prone. But with AI-driven project planning software, you can scale our workload by automatically generating construction requirements with no human error involved.

Utilising AI for Improved Quality Control

Quality control is a process that ensures the quality of a product or service meets the company’s specifications. It is also responsible for preventing defects from ever reaching the customer. Quality control has been around for decades and has helped many companies improve their processes.

But how would Artificial Intelligence help in this process? With AI, companies can automate the quality control process with machine learning algorithms. These algorithms can analyze data and find patterns to detect problems early on and predict failures before they happen. This will save time and money in the long run by preventing defects from happening in the first place.

AI in Requirement Management vs Traditional Method for Requirement Management

AI in requirement management is not a replacement for the traditional process. It is an addition to it. Artificial Intelligence can help to find requirements that are not in the scope of the project and also find duplicates.

Conclusion

The future of implementing AI in requirement management is here and it is only going to get better. It has been a long time since the first Artificial Intelligence (AI) was created. And while it has taken a while for AI to be implemented into many industries, we are now seeing the benefits of Artificial Intelligence in the workplace. One of these benefits is that Artificial Intelligence can help with requirement management. It is an important part of any organisation's life cycle because it allows them to plan for what they need and when they need it. It also helps them understand what their needs are so that they can plan accordingly. But with all this planning, there needs to be someone who can keep up with all the changes that happen along the way.

• Click to explore the differences between NLP, NLU, and NLG
• Explore here about Machine Learning Model Visualization

Original article source at: https://www.xenonstack.com/

#AI #management