Introductory Lecture to 5.310

MIT 5.310 Laboratory Chemistry, Fall 2019
Instructor: John Dolhun
View the complete course: https://ocw.mit.edu/5-310F19

In this first lecture, Dr. John Dolhun introduces the teaching team, policies, course format, expectations, grading, and material to be covered during the semester. He also discusses lab notebooks and lab safety rules, then demonstrates a polymer reaction.

License: Creative Commons BY-NC-SA
More information at https://ocw.mit.edu/terms
More courses at https://ocw.mit.edu
Support OCW at http://ow.ly/a1If50zVRlQ

#developer

What is GEEK

Buddha Community

Introductory Lecture to 5.310
ERIC  MACUS

ERIC MACUS

1647540000

Substrate Knowledge Map For Hackathon Participants

Substrate Knowledge Map for Hackathon Participants

The Substrate Knowledge Map provides information that you—as a Substrate hackathon participant—need to know to develop a non-trivial application for your hackathon submission.

The map covers 6 main sections:

  1. Introduction
  2. Basics
  3. Preliminaries
  4. Runtime Development
  5. Polkadot JS API
  6. Smart Contracts

Each section contains basic information on each topic, with links to additional documentation for you to dig deeper. Within each section, you'll find a mix of quizzes and labs to test your knowledge as your progress through the map. The goal of the labs and quizzes is to help you consolidate what you've learned and put it to practice with some hands-on activities.

Introduction

One question we often get is why learn the Substrate framework when we can write smart contracts to build decentralized applications?

The short answer is that using the Substrate framework and writing smart contracts are two different approaches.

Smart contract development

Traditional smart contract platforms allow users to publish additional logic on top of some core blockchain logic. Since smart contract logic can be published by anyone, including malicious actors and inexperienced developers, there are a number of intentional safeguards and restrictions built around these public smart contract platforms. For example:

Fees: Smart contract developers must ensure that contract users are charged for the computation and storage they impose on the computers running their contract. With fees, block creators are protected from abuse of the network.

Sandboxed: A contract is not able to modify core blockchain storage or storage items of other contracts directly. Its power is limited to only modifying its own state, and the ability to make outside calls to other contracts or runtime functions.

Reversion: Contracts can be prone to undesirable situations that lead to logical errors when wanting to revert or upgrade them. Developers need to learn additional patterns such as splitting their contract's logic and data to ensure seamless upgrades.

These safeguards and restrictions make running smart contracts slower and more costly. However, it's important to consider the different developer audiences for contract development versus Substrate runtime development.

Building decentralized applications with smart contracts allows your community to extend and develop on top of your runtime logic without worrying about proposals, runtime upgrades, and so on. You can also use smart contracts as a testing ground for future runtime changes, but done in an isolated way that protects your network from any errors the changes might introduce.

In summary, smart contract development:

  • Is inherently safer to the network.
  • Provides economic incentives and transaction fee mechanisms that can't be directly controlled by the smart contract author.
  • Provides computational overhead to support graceful logical failures.
  • Has a low barrier to entry for developers and enables a faster pace of community interaction.

Substrate runtime development

Unlike traditional smart contract development, Substrate runtime development offers none of the network protections or safeguards. Instead, as a runtime developer, you have total control over how the blockchain behaves. However, this level of control also means that there is a higher barrier to entry.

Substrate is a framework for building blockchains, which almost makes comparing it to smart contract development like comparing apples and oranges. With the Substrate framework, developers can build smart contracts but that is only a fraction of using Substrate to its full potential.

With Substrate, you have full control over the underlying logic that your network's nodes will run. You also have full access for modifying and controlling each and every storage item across your runtime modules. As you progress through this map, you'll discover concepts and techniques that will help you to unlock the potential of the Substrate framework, giving you the freedom to build the blockchain that best suits the needs of your application.

You'll also discover how you can upgrade the Substrate runtime with a single transaction instead of having to organize a community hard-fork. Upgradeability is one of the primary design features of the Substrate framework.

In summary, runtime development:

  • Provides low level access to your entire blockchain.
  • Removes the overhead of built-in safety for performance.
  • Has a higher barrier of entry for developers.
  • Provides flexibility to customize full-stack application logic.

To learn more about using smart contracts within Substrate, refer to the Smart Contract - Overview page as well as the Polkadot Builders Guide.

Navigating the documentation

If you need any community support, please join the following channels based on the area where you need help:

Alternatively, also look for support on Stackoverflow where questions are tagged with "substrate" or on the Parity Subport repo.

Use the following links to explore the sites and resources available on each:

Substrate Developer Hub has the most comprehensive all-round coverage about Substrate, from a "big picture" explanation of architecture to specific technical concepts. The site also provides tutorials to guide you as your learn the Substrate framework and the API reference documentation. You should check this site first if you want to look up information about Substrate runtime development. The site consists of:

Knowledge Base: Explaining the foundational concepts of building blockchain runtimes using Substrate.

Tutorials: Hand-on tutorials for developers to follow. The first SIX tutorials show the fundamentals in Substrate and are recommended for every Substrate learner to go through.

How-to Guides: These resources are like the O'Reilly cookbook series written in a task-oriented way for readers to get the job done. Some examples of the topics overed include:

  • Setting up proper weight functions for extrinsic calls.
  • Using off-chain workers to fetch HTTP requests.
  • Writing tests for your pallets It can also be read from

API docs: Substrate API reference documentation.

Substrate Node Template provides a light weight, minimal Substrate blockchain node that you can set up as a local development environment.

Substrate Front-end template provides a front-end interface built with React using Polkadot-JS API to connect to any Substrate node. Developers are encouraged to start new Substrate projects based on these templates.

If you face any technical difficulties and need support, feel free to join the Substrate Technical matrix channel and ask your questions there.

Additional resources

Polkadot Wiki documents the specific behavior and mechanisms of the Polkadot network. The Polkadot network allows multiple blockchains to connect and pass messages to each other. On the wiki, you can learn about how Polkadot—built using Substrate—is customized to support inter-blockchain message passing.

Polkadot JS API doc: documents how to use the Polkadot-JS API. This JavaScript-based API allows developers to build custom front-ends for their blockchains and applications. Polkadot JS API provides a way to connect to Substrate-based blockchains to query runtime metadata and send transactions.

Quiz #1

👉 Submit your answers to Quiz #1

Basics

Set up your local development environment

Here you will set up your local machine to install the Rust compiler—ensuring that you have both stable and nightly versions installed. Both stable and nightly versions are required because currently a Substrate runtime is compiled to a native binary using the stable Rust compiler, then compiled to a WebAssembly (WASM) binary, which only the nightly Rust compiler can do.

Also refer to:

Lab #1

👉 Complete Lab #1: Run a Substrate node

Interact with a Substrate network using Polkadot-JS apps

Polkadot JS Apps is the canonical front-end to interact with any Substrate-based chain.

You can configure whichever endpoint you want it to connected to, even to your localhost running node. Refer to the following two diagrams.

  1. Click on the top left side showing your currently connected network:

assets/01-polkadot-app-endpoint.png

  1. Scroll to the bottom of the menu, open DEVELOPMENT, and choose either Local Node or Custom to specify your own endpoint.

assets/02-polkadot-app-select-endpoint.png

Quiz #2

👉 Complete Quiz #2

Lab #2

👉 Complete Lab #2: Using Polkadot-JS Apps

Notes: If you are connecting Apps to a custom chain (or your locally-running node), you may need to specify your chain's custom data types in JSON under Settings > Developer.

Polkadot-JS Apps only receives a series of bytes from the blockchain. It is up to the developer to tell it how to decode and interpret these custom data type. To learn more on this, refer to:

You will also need to create an account. To do so, follow these steps on account generation. You'll learn that you can also use the Polkadot-JS Browser Plugin (a Metamask-like browser extension to manage your Substrate accounts) and it will automatically be imported into Polkadot-JS Apps.

Notes: When you run a Substrate chain in development mode (with the --dev flag), well-known accounts (Alice, Bob, Charlie, etc.) are always created for you.

Lab #3

👉 Complete Lab #3: Create an Account

Preliminaries

You need to know some Rust programming concepts and have a good understanding on how blockchain technology works in order to make the most of developing with Substrate. The following resources will help you brush up in these areas.

Rust

You will need familiarize yourself with Rust to understand how Substrate is built and how to make the most of its capabilities.

If you are new to Rust, or need a brush up on your Rust knowledge, please refer to The Rust Book. You could still continue learning about Substrate without knowing Rust, but we recommend you come back to this section whenever in doubt about what any of the Rust syntax you're looking at means. Here are the parts of the Rust book we recommend you familiarize yourself with:

  • ch 1 - 10: These chapters cover the foundational knowledge of programming in Rust
  • ch 13: On iterators and closures
  • ch 18 - 19: On advanced traits and advanced types. Learn a bit about macros as well. You will not necessarily be writing your own macros, but you'll be using a lot of Substrate and FRAME's built-in macros to write your blockchain runtime.

How blockchains work

Given that you'll be writing a blockchain runtime, you need to know what a blockchain is, and how it works. The **Web3 Blockchain Fundamental MOOC Youtube video series provides a good basis for understanding key blockchain concepts and how blockchains work.

The lectures we recommend you watch are: lectures 1 - 7 and lecture 10. That's 8 lectures, or about 4 hours of video.

Quiz #3

👉 Complete Quiz #3

Substrate runtime development

High level architecture

To know more about the high level architecture of Substrate, please go through the Knowledge Base articles on Getting Started: Overview and Getting Started: Architecture.

In this document, we assume you will develop a Substrate runtime with FRAME (v2). This is what a Substrate node consists of.

assets/03-substrate-architecture.png

Each node has many components that manage things like the transaction queue, communicating over a P2P network, reaching consensus on the state of the blockchain, and the chain's actual runtime logic (aka the blockchain runtime). Each aspect of the node is interesting in its own right, and the runtime is particularly interesting because it contains the business logic (aka "state transition function") that codifies the chain's functionality. The runtime contains a collection of pallets that are configured to work together.

On the node level, Substrate leverages libp2p for the p2p networking layer and puts the transaction pool, consensus mechanism, and underlying data storage (a key-value database) on the node level. These components all work "under the hood", and in this knowledge map we won't cover them in detail except for mentioning their existence.

Quiz #4

👉 Complete Quiz #4

Runtime development topics

In our Developer Hub, we have a thorough coverage on various subjects you need to know to develop with Substrate. So here we just list out the key topics and reference back to Developer Hub. Please go through the following key concepts and the directed resources to know the fundamentals of runtime development.

Key Concept: Runtime, this is where the blockchain state transition function (the blockchain application-specific logic) is defined. It is about composing multiple pallets (can be understood as Rust modules) together in the runtime and hooking them up together.

Runtime Development: Execution, this article describes how a block is produced, and how transactions are selected and executed to reach the next "stage" in the blockchain.

Runtime Develpment: Pallets, this article describes what the basic structure of a Substrate pallet is consists of.

Runtime Development: FRAME, this article gives a high level overview of the system pallets Substrate already implements to help you quickly develop as a runtime engineer. Have a quick skim so you have a basic idea of the different pallets Substrate is made of.

Lab #4

👉 Complete Lab #4: Adding a Pallet into a Runtime

Runtime Development: Storage, this article describes how data is stored on-chain and how you could access them.

Runtime Development: Events & Errors, this page describe how external parties know what has happened in the blockchain, via the emitted events and errors when executing transactions.

Notes: All of the above concepts we leverage on the #[pallet::*] macro to define them in the code. If you are interested to learn more about what other types of pallet macros exist go to the FRAME macro API documentation and this doc on some frequently used Substrate macros.

Lab #5

👉 Complete Lab #5: Building a Proof-of-Existence dApp

Lab #6

👉 Complete Lab #6: Building a Substrate Kitties dApp

Quiz #5

👉 Complete Quiz #5

Polkadot JS API

Polkadot JS API is the javascript API for Substrate. By using it you can build a javascript front end or utility and interact with any Substrate-based blockchain.

The Substrate Front-end Template is an example of using Polkadot JS API in a React front-end.

  • Runtime Development: Metadata, this article describes the API allowing external parties to query what API is open for the chain. Polkadot JS API makes use of a chain's metadata to know what queries and functions are available from a chain to call.

Lab #7

👉 Complete Lab #7: Using Polkadot-JS API

Quiz #6

👉 Complete Quiz #6: Using Polkadot-JS API

Smart contracts

Learn about the difference between smart contract development vs Substrate runtime development, and when to use each here.

In Substrate, you can program smart contracts using ink!.

Quiz #7

👉 Complete Quiz #7: Using ink!

What we do not cover

A lot 😄

On-chain runtime upgrades. We have a tutorial on On-chain (forkless) Runtime Upgrade. This tutorial introduces how to perform and schedule a runtime upgrade as an on-chain transaction.

About transaction weight and fee, and benchmarking your runtime to determine the proper transaction cost.

Off-chain Features

There are certain limits to on-chain logic. For instance, computation cannot be too intensive that it affects the block output time, and computation must be deterministic. This means that computation that relies on external data fetching cannot be done on-chain. In Substrate, developers can run these types of computation off-chain and have the result sent back on-chain via extrinsics.

Tightly- and Loosely-coupled pallets, calling one pallet's functions from another pallet via trait specification.

Blockchain Consensus Mechansim, and a guide on customizing it to proof-of-work here.

Parachains: one key feature of Substrate is the capability of becoming a parachain for relay chains like Polkadot. You can develop your own application-specific logic in your chain and rely on the validator community of the relay chain to secure your network, instead of building another validator community yourself. Learn more with the following resources:

Terms clarification

  • Substrate: the blockchain development framework built for writing highly customized, domain-specific blockchains.
  • Polkadot: Polkadot is the relay chain blockchain, built with Substrate.
  • Kusama: Kusama is Polkadot's canary network, used to launch features before these features are launched on Polkadot. You could view it as a beta-network with real economic value where the state of the blockchain is never reset.
  • Web 3.0: is the decentralized internet ecosystem that, instead of apps being centrally stored in a few servers and managed by a sovereign party, it is an open, trustless, and permissionless network when apps are not controlled by a centralized entity.
  • Web3 Foundation: A foundation setup to support the development of decentralized web software protocols. Learn more about what they do on thier website.

Others


Author: substrate-developer-hub
Source Code: https://github.com/substrate-developer-hub/hackathon-knowledge-map
License: 

#blockchain #substrate 

Ethen Ellen

1619519725

Immediate $olution to Fix AOL Blerk Error Code 5 with easy instructions

This is image title

AOL Email is one of the leading web email services. It has a number of features who access easily at any place. Through this, you can easily share messages, documents or files, etc.AOL Blerk Error is not a big issue. It is a temporary error and it occurs when there is an issue in loading messages from the AOL server. If your mind is stuck, How to Resolve or Fix AOL Blerk Error Code 5? Here, In this article, we mentioned troubleshooting steps to fix AOL Blerk Error Code 5.

What are the causes of AOL Blerk Error Code 5?

AOL mail usually presents an AOL Blerk Error 5 after the AOL connection details have been entered. meaning. Your password and your username. This error is usually found in words! Or 'BLERK! Error 5 Authentication problem, 'Your sign-in has been received.

Some of the reasons for the error are as follows:
• Internet browser configuration problem

• Saved erroneous bookmark addresses

• browser cache or cookie

• An AOL Desktop Gold technical error.
How to Fix AOL Mail Blerk Error 5 in a Simple Way

This type of error is mostly due to your browser settings or the use of outdated, obsolete software. Users should remember that the steps to solve problems vary, depending on the browser you are using. Here are the steps to fix the mistake, check your browser and follow the steps.

Internet Explorer: Make sure you use the most recent web browser version. Open a new window and follow the “Tools> Web Options> Security> Internet Zone” thread. Activate ‘Safeguard Mode’ and follow the steps to include AOL Mail in the list of assured websites. Start the browser again to save changes and run Internet Explorer without additional information.
Firefox Mozilla: Open a new Firefox window and press Menu. To start the browser in safe mode, disable the add-on and choose the option to restart Firefox. You can see two options in the dialog box. Use the “Start in Safe Mode” option to disable all themes and extensions. The browser also turns off the hardware speed and resets the toolbar. You should be able to execute AOL mail when this happens.

Google Chrome: Update to the latest version of Chrome. Open the browser and go to the Advanced Options section. Go to ‘Security and Privacy’ and close the appropriate add-ons. Once the browsing history is deleted, the password, cookies saved and the cache will be cleared. Restart your system and try to log in to your AOL account with a new window.

Safari: Some pop-up windows block AOL mail when it comes to Safari and causes authentication issues. To fix the error, use Safari Security Preferences to enable the pop-up window and disable the security warning.

If you see, even when you change the required browser settings, the black error will not disappear, you can consult a skilled professional and see all the AOL email customer support numbers.

Get Connect to Fix Blerk Error Even After Clearing Cache & Cookies?
Somehow you can contact AOL technical support directly and get immediate help if you still get the error. Call +1(888)857-5157 to receive assistance from the AOL technical support team.

Source: https://email-expert247.blogspot.com/2021/04/immediate-olution-to-fix-aol-blerk.html “How to Resolve or Fix AOL Blerk Error Code 5”)**? Here, In this article, we mentioned troubleshooting steps to fix AOL Blerk Error Code 5.

What are the causes of AOL Blerk Error Code 5?

AOL mail usually presents an AOL Blerk Error 5 after the AOL connection details have been entered. meaning. Your password and your username. This error is usually found in words! Or 'BLERK! Error 5 Authentication problem, 'Your sign-in has been received.

Some of the reasons for the error are as follows:
• Internet browser configuration problem

• Saved erroneous bookmark addresses

• browser cache or cookie

• An AOL Desktop Gold technical error.
How to Fix AOL Mail Blerk Error 5 in a Simple Way

This type of error is mostly due to your browser settings or the use of outdated, obsolete software. Users should remember that the steps to solve problems vary, depending on the browser you are using. Here are the steps to fix the mistake, check your browser and follow the steps.

  1. Internet Explorer: Make sure you use the most recent web browser version. Open a new window and follow the “Tools> Web Options> Security> Internet Zone” thread. Activate ‘Safeguard Mode’ and follow the steps to include AOL Mail in the list of assured websites. Start the browser again to save changes and run Internet Explorer without additional information.

  2. Firefox Mozilla: Open a new Firefox window and press Menu. To start the browser in safe mode, disable the add-on and choose the option to restart Firefox. You can see two options in the dialog box. Use the “Start in Safe Mode” option to disable all themes and extensions. The browser also turns off the hardware speed and resets the toolbar. You should be able to execute AOL mail when this happens.

  3. Google Chrome: Update to the latest version of Chrome. Open the browser and go to the Advanced Options section. Go to ‘Security and Privacy’ and close the appropriate add-ons. Once the browsing history is deleted, the password, cookies saved and the cache will be cleared. Restart your system and try to log in to your AOL account with a new window.

  4. Safari: Some pop-up windows block AOL mail when it comes to Safari and causes authentication issues. To fix the error, use Safari Security Preferences to enable the pop-up window and disable the security warning.

If you see, even when you change the required browser settings, the black error will not disappear, you can consult a skilled professional and see all the AOL email customer support numbers.

Get Connect to Fix Blerk Error Even After Clearing Cache & Cookies?

Somehow you can contact AOL technical support directly and get immediate help if you still get the error. Call +1(888)857-5157 to receive assistance from the AOL technical support team.

Source: https://email-expert247.blogspot.com/2021/04/immediate-olution-to-fix-aol-blerk.html

#aol blerk error code 5 #aol blerk error 5 #aol mail blerk error code 5 #aol mail blerk error 5 #aol error code 5 #aol error 5

Devan  Johnson

Devan Johnson

1600713120

Laravel 5.5 Artisan Console Tutorial

Laravel 5.5 Artisan Console Tutorial is today’s topic. Artisan Command Line Interface comes with brand new Laravel project out of the box. There are so many commands Laravel application provides us by default. There so many tasks in your application that can be very well handled by command line tools. So this tutorial is dedicated to Laravel 5.5 Commands. You can list all the Laravel 5.5 Commands by the typing following command.

php artisan list

Laravel 5.5 Artisan Console Tutorial

If you are new to Laravel 5.5 then check out my these tutorials on this blog.

  1. Laravel 5.5 Tutorial With Example From Scratch
  2. Laravel 5 Middleware Tutorial With An Example

#laravel #laravel 5.5 #laravel 5.5 artisan

Jacob Banks

Jacob Banks

1648437196

Securing REST API using Spring Security, OAuth2 and Keycloak

Spring Boot, Security, PostgreSQL, and Keycloak REST API OAuth2

The comprehensive step by step Spring Boot tutorial on securing REST API using Spring Security OAuth2 as resources server and Keycloak as the Authorization server

This tutorial is divided into several steps:

Step #1: Setup Keycloak Authorization Server
Step #2: Create Spring Boot Application
Step #3: Configure Spring Security and Oauth2
Step #4: Create Spring Data Entity, Repository, Service, and Rest Controller
Step #5: Run and Test using Postman


The step by step Spring Boot tutorial on securing REST API using Spring Security OAuth2 as resources and Keycloak as the Authorization server

Before this, Spring have its own OAuth2 Authorization Server module then it's deprecated. But, we have other options that have already been established like Gluu and Keycloak. For this tutorial, we will use Keycloak as an Authorization server since it's recommended by Spring when the OAuth2 support ends in Spring version 2.4.0. We will use Spring Boot and PostgreSQL as resources servers.

This tutorial is divided into several steps:

  • Step #1: Setup Keycloak Authorization Server
  • Step #2: Create Spring Boot Application
  • Step #3: Configure Spring Security and Oauth2
  • Step #4: Create Spring Data Entity, Repository, Service, and Rest Controller
  • Step #5: Run and Test using Postman

Step #1: Setup Keycloak Authorization Server

Setup Keycloak

We will use a standalone Keycloak server that can be downloaded from the official Keycloak Download. Download the latest Keycloak server, for this time we will use version 17.0. 

keycloak-download

Extract to your project directory, open the terminal or command line then go to the extracted Keycloak directory. 

cd ~/SpringApps/keycloak-17.0.0

Edit the configuration file to use the PostgreSQL database.

nano conf/keycloak.conf

Uncomment db, db-username, db-password, and db-url then give them your PostgreSQL configuration parameters.

Save this file then go to the PostgreSQL console.

psql postgres

Next, type this command for creating a new user with a password then give access for creating the database.

CREATE ROLE djamware WITH LOGIN PASSWORD 'dj@mw@r3';
ALTER ROLE djamware CREATEDB;

Quit PostgreSQL console then log in again using the new user that was previously created.

\q
psql postgres -U djamware

Type this command to create a new database.

CREATE DATABASE keycloak;

Then give that new user privileges to the new database then quit the PostgreSQL console.

GRANT ALL PRIVILEGES ON DATABASE keycloak TO djamware;
\q

Run and Configure Keycloak

To run Keycloak as a standalone server, go to the bin directory the run the Keycloak server.

cd bin
./kc.sh start-dev

Open your browser then go to http://localhost:8080. 

keycloak-initial-page

Fill in the admin username, password, and password confirmation then click the Create button. Click the Administration console button the log in using the previously created username and password.

keycloak-admin-login

And here the Keycloak admin dashboard with the default Realm is master.

keycloak-admin-dashboard

To create a new realm, click the dropdown of the Master menu in the left menu then click Add Realm.

keycloak-add-realm-button

Fill in the name and enable it on then click the Create button.

keycloak-add-realm

Now, the new realm is created, and the dashboard change to the new realm.

keycloak-new-realm-dashboard

Next, create a new client by clicking the Clients menu on the left.

keycloak-clients-list

Click the Create button at the top right of the client's table.

keycloak-add-client

Fill in the required fields such as client ID, client protocol, and root URL then click the Save button.

keycloak-client-settings

In the client settings, leave everything as default except the Valid Redirect URL. Fill with your Spring Boot resource server URL with an Asterix.

keycloak-client-redirect-url

Next, create a new role by clicking on the Roles menu on the left.

keycloak-roles-list

Click the Add Role button in the top right of the roles table.

keycloak-add-role

Click the Save button and it will be redirected to the role details.

keycloak-role-details

Next, click the Users menu in the bottom left menu.

keycloak-users-list

Click the Add User button then fill in all required fields as below.

keycloak-add-user

Click the Save button and it will be redirected to the user details page.

keycloak-user-details

Click the role mappings tab then choose user in the Available Roles then click Add selected.

keycloak-role-mappings

Now, the user will appear in the Roles -> Users in the Role tab. Next, on the user details page, click the Credentials tab then fill the password and password confirmation fields with your password. Make sure the Temporary switch is OFF otherwise it will be required to reset the password before using it.

keycloak-user-credentials

Click the set password button then accept the confirmation dialog. Now, the Keycloak and users is ready to use. We can test to get the token using postman. In the postman, make a POST request with URL http://localhost:8080/realms/djamware/protocol/openid-connect/token. Fill the request body these x-www-form-urlencoded fields.

postman-post-oauth-token

Click the Send button, and you will see this Postman response from the Keycloak server.

postman-response


Step #2: Create Spring Boot Application

To generate a Spring Boot starter application and Spring Boot OAuth2 Resource Server, go to Spring Initializer. Choose Maven Project, Java Language, Spring Boot version 2.6.4, or stable version. In Project Metadata, create your own group or default package (ours: com.djamware), Artifact is oauthresource, Name is oauthresource, Packaging is Jar, and Java version is 11. In Dependencies, choose Web, OAuth2 Resource Server, Spring Security, PostgreSQL Driver, and Spring Data JPA.

spring-initializer

Click the Generate button to download the initial Spring Boot project then extract it to your Spring Boot projects folder. Open this Spring Boot application project using your IDE (Netbeans, IntelliJIDEA, Eclipse, or VSCode). Next, open and edit pom.xml file then add this dependency.

        <dependency>
            <groupId>org.modelmapper</groupId>
            <artifactId>modelmapper</artifactId>
            <version>3.0.0</version>
        </dependency>

Reload Maven changes to download and install the newly added dependency.


Step #3: Configure Spring Security and Oauth2

We will use application.yml instead of the application.properties file. For that, rename the application.properties file to application.yml then replace/add these lines of YML configurations which are server port, PostgreSQL connection, and Spring Security OAuth2 resource server.

server:
  port: 8083

spring:
  jpa:
    database: POSTGRESQL
    show-sql: true
    hibernate:
      ddl-auto: create
  datasource:
    platform: postgres
    url: jdbc:postgresql://localhost:5432/myoauth2
    username: djamware
    password: dj@mw@r3
    driver-class-name: org.postgresql.Driver
  security:
    oauth2:
      resourceserver:
        jwt:
          issuer-uri: http://localhost:8080/realms/djamware
          jwk-set-uri: http://localhost:8080/realms/djamware/protocol/openid-connect/certs

As you can see, we are using port 8083 to run this Spring Boot resource server because the default port 8080 is used by Keycloak standalone server. We need to create a database for this resource server. For that, enter the PostgreSQL console from the terminal.

Type this command to create a new database.

CREATE DATABASE myoauth2;

Then give that user privileges to the new database then quit the PostgreSQL console.

GRANT ALL PRIVILEGES ON DATABASE myoauth2 TO djamware;
\q

To find out Keycloak JWT issuer-ur and jwk-set-uri, you can check it using postman to this URL http://localhost:8080/realms/djamware/.well-known/openid-configuration using GET method.

Next, we need to add Spring Security config by creating a new package com/djamware/oauthresource/config and a file SecurityConfig.java inside that package. Replace the codes in this file with these codes.

package com.djamware.oauthresource.config;

import org.modelmapper.ModelMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Bean
    public ModelMapper modelMapper() {
        return new ModelMapper();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.cors()
                .and()
                .authorizeRequests()
                .antMatchers(HttpMethod.GET, "/api/boards")
                .hasAuthority("user")
                .anyRequest()
                .authenticated()
                .and()
                .oauth2ResourceServer()
                .jwt();
    }
}

The ModelMapper inject into this configuration because will be used in entity to DTO converter. The Spring Security is securing /api/boards endpoint with Authority user that previously created in Keycloak. Also, configure Oauth2ResourceServer and JWT as tokens that will be used when the secure endpoint is accessed.

 

 


Step #4: Create Spring Data Entity, Repository, Service, and Rest Controller

Before creating an entity or models that will use in Spring Boot OAuth2 resource server, create a new package with the name com/djamware/oauthresource/entity and a Java file with the name Board.java. Replace all Java codes with this.

package com.djamware.oauthresource.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import java.util.Date;

@Entity
public class Board {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String title;
    private String content;
    private String author;
    private Date createdAt;

    public Board() {}

    public Board(Long id, String title, String content, String author, Date createdAt) {
        this.id = id;
        this.title = title;
        this.content = content;
        this.author = author;
        this.createdAt = createdAt;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Date getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }
}

If you want less code for entity or model class, you can use Lombok.

Next, before creating a repository that will use by the service or controller, create a new package with the name com/djamware/oauthresource/repository and a Java interface file with the name BoardRepository.java. Replace all Java interface codes with this.

package com.djamware.oauthresource.repository;

import com.djamware.oauthresource.entity.Board;
import org.springframework.data.repository.PagingAndSortingRepository;

public interface IBoardRepository extends PagingAndSortingRepository<Board, Long> {
}

That repository is very simple because we just need to get a list from the model. Next, create a com/djamware/oauthresource/service package, an interface file IBoardService.java, and a class file BoardServiceImpl.java. Replace all codes in IBoardService.java with this.

package com.djamware.oauthresource.service;

import com.djamware.oauthresource.entity.Board;

public interface IBoardService {
    Iterable<Board> findAll();
}

Next, replace all codes in BoardServiceImpl.java with this.

package com.djamware.oauthresource.service;

import com.djamware.oauthresource.entity.Board;
import com.djamware.oauthresource.repository.IBoardRepository;
import org.springframework.stereotype.Service;

@Service
public class BoardServiceImpl implements IBoardService {
    private final IBoardRepository boardRepository;

    public BoardServiceImpl(IBoardRepository boardRepository) {
        this.boardRepository = boardRepository;
    }

    @Override
    public Iterable<Board> findAll() {
        return boardRepository.findAll();
    }
}

Next, create a new Rest Controller by creating a new package first com/djamware/oauthresource/controller and then a class file BoardController.java inside that package. Replace all codes inside BoardController.java with this.

package com.djamware.oauthresource.controller;

import com.djamware.oauthresource.dto.BoardDto;
import com.djamware.oauthresource.entity.Board;
import com.djamware.oauthresource.service.IBoardService;
import org.modelmapper.ModelMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@RestController
public class BoardController {
    private IBoardService boardService;

    public BoardController(IBoardService boardService) {
        this.boardService = boardService;
    }

    @Autowired
    private ModelMapper modelMapper;

    @GetMapping("/api/boards")
    public Collection<BoardDto> findAll() {
        Iterable<Board> boards = this.boardService.findAll();
        List<BoardDto> boardDtos = new ArrayList<>();
        boards.forEach(b -> boardDtos.add(convertToDto(b)));
        return boardDtos;
    }

    protected BoardDto convertToDto(Board board) {
        BoardDto boardDto = modelMapper.map(board, BoardDto.class);
        return boardDto;
    }
}

Also, create a DTO file by creating a new package first com/djamware/oauthresource/dto then a class file BoardDto.java inside that package. Replace all codes inside BoardDto.java with this.

package com.djamware.oauthresource.dto;

import com.fasterxml.jackson.annotation.JsonAutoDetect;

import java.util.Date;

@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility.ANY)
public class BoardDto {
    private long id;
    private String title;
    private String content;
    private String author;
    private Date createdAt;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Date getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(Date createdAt) {
        this.createdAt = createdAt;
    }
}

That REST controller mapping the board list result to secure /api/boards endpoint. The model result is converted to JSON DTO before returning to the REST response. 


Step #5: Run and Test using Postman

Before running this Spring Boot OAuth2 resource server, make sure the Keycloak standalone authorization server is running. Inside the keycloak-17.0.0/bin directory type this command.

./kc.sh start-dev

To run Spring Boot OAuth2 resource server, simply type this command.

mvn clean spring-boot:run

After running the Spring Boot application, load this dummy data to the database.

INSERT INTO board(title, content, author, created_at) VALUES('New Spring Boot Articles', 'Didin J.', 'The new Spring Boot article is available on Djamware.com', current_timestamp);
INSERT INTO board(title, content, author, created_at) VALUES('Live Tutorial on YouTube', 'Didin J.', 'Live Tutorial about basic Java on YouTube at May 21, 2022', current_timestamp);
INSERT INTO board(title, content, author, created_at) VALUES('The next stream on Monday', 'Didin J.', 'The next stream on Monday', current_timestamp);

Next, open the postman then make a GET request to http://localhost:8083/api/boards/ with response type JSON.

unauthenticated-postman-get

That request should respond with status 401 Unauthorized. To make an Authorized request, first, we need to get a token from the Keycloak by making a new Postman request with POST method and Url http://localhost:8080/realms/djamware/protocol/openid-connect/token. Use x-ww-form-urlencoded body with these variables.

postman-get-token

When hitting the Send button, it should respond to the JWT token like this.

jwt-response

Just copy the access_token value to the Get Boards request headers with key name Authorization and value Bearer + JWT token.

authorized-request

 

 

When hitting the Send button, it should respond to the JSON array like this.

authorized-response

That it's, Spring Boot, Security, PostgreSQL, and Keycloak REST API OAuth2. You can get the source code from our GitHub.

Full article:
https://www.djamware.com 

Full source code:
https://github.com 

#springboot #oauth2 #security #postgresql #rest #api #oauth

SumatoSoft

SumatoSoft

1650002573

How a Discovery Phase of a Project Leads to Success For Our Clients

When it comes to wondering about the relevance of the development of additional systems or a new product, it can be tricky to assess risks, remove uncertainty and doubt, and make a final decision based on the data and not on the endless set of assumptions. Also, you may discover that you don’t have the necessary knowledge and experience to develop the necessary solution.  

Unfortunately, projects fail. But there is an option to increase the chances of success up to 50%. 

According to a McKinsey report, one of the world’s most prestigious consulting firms,   50% of projects fail because of poor requirement definitions. This is old data, we agree. 

According to St. Cloud State University report, a leading public university in the Upper Midwest of the United States, 48% of projects experienced project time or budget overrun because of poor and incomplete requirements

St Cloud State University report

As a leading software development company with 9 years of experience, we can say that these figures are true. That is why we want to share with you our expertise about the Discovery Phase of a project that allows businesses to increase their chances of project success up to 50%! 

We split our article into 3 logical parts: 

In Part 1 we make a Discovery Phase overview. We look at its meaning, participants, purposes, how much time it takes and money required, who participates in it.

In Part 2 we describe how we run the Discovery Phase in agile for our clients and lead them to success. We also list the tools we use during this phase. 

In Part 3 you will read about what our clients get as a result of the Discovery phase and what benefits they reap.

For those who prefer to get information in a condensed form, we prepared a table with key messages about the project Discovery Phase. 

Enjoy reading!

A Discovery Phase in One Table

Key definitionsDetails
What isthe research of requirements and business goals at the very beginning of the project
Purposes

Precise budget and timeframe estimation 

The comprehensive shared vision of the whole project

The development team gets tools to make a great solution

Less uncertainty

ParticipantsProject manager, Business Analyst, Technical expert, UX/UI designer (optional), Software architect
Top benefits

Reduce development costs as much as 50%

Validate your business/product idea

Cut time-to-market by 20% 

Improve requirement management

Duration and price

From 1 to 3 month 

From 15.000$ to 25.000$

Key steps

Step 1: The Initial interview. Requirements elicitation. 

Step #2: The discovery of users and their needs

Step #3: Writing of the Vision and Scope document 

Step #4: Prototyping 

Step #5: Documentation of Software Requirement Specification (SRS)

Key deliverables

Product Vision and Scope 

Software requirements specification (SRS) 

Prototype designed at a high level 

Development roadmap with timeline and budget

Part 1: A Comprehensive Guide about a Discovery Phase

planning discovery phase

 

What is a Discovery Phase

A project Discovery Phase is the research of requirements and business goals at the start of the project. At that phase, we: 

  • flash out your business goals (what you want to achieve)
  • identify your target audience and their needs and requirements (what user issues you want to solve)
  • define the scope of work
  • estimate risks and assumptions
  • find the best technical solution
  • create a vision of the solution
  • and last but not the least, we document all this information.

During that phase, we need to cover such topics, like: 

  1. Design
  2. Working environment (devices and platforms)
  3. Technical preferences (e.g. databases)
  4. Integrations with third-party service providers
  5. Legislation limitations
  6. Localization
  7. Performance
  8. Reliability
  9. Security
  10. And much more.

What are the Purposes of a Discovery Phase

BA specialists

The positive effect of a Discovery Phase on development is hard to underestimate. We want to mention 4 goals why to conduct it: 

Purpose #1 Precise budget and timeline estimation 

The Discovery Phase of a project is the only possible option to make a precise estimation for a complex project since it reveals your goals, your client’s needs, the scope of work, external and internal limitations. 

Purpose #2 The comprehensive shared vision of the whole project 

Research results are fully documented. Hence, business goals, success metrics, user profiles, the project vision, and architecture become clearly defined for all stakeholders and become available anytime.

Purpose #3 The development team gets tools to make a great solution

Requirements lie at the very core of any software. The developers, designers, QA engineers use requirements in their work to make a great software product. Clearly defined requirements significantly increase the chances to release the product within timeframes, budget, and with due regard to business goals. 

Purpose #4 Less uncertainty

Launching a new product is a risky venture. Just some examples are budget overrun, no-market fit, missing vital requirements, implementation of not an optimal solution, etc. The Discovery Phase of a project helps to remove most of the uncertainty. ‍

Participants Of a Discovery Phase Of a Project

planning development strategy

Normally, a project manager, business analyst, and one technical expert form a team that can handle this phase. However, the more complex the project leads to the increase in the number of team members. From our perspective we can list the next specialists: 

Project manager 

Responsible for flawless communication of the discovery team and the client. This specialist is accountable for planning and tracking the progress of the phase. 

Business analyst 

Business analysts do the research and prepare 80-100% of the final documentation. BA must have various specific skills to spot the challenges and find the solution for them.

Good Business Analysts have a very clear vision of what information they should ask about to make sure that they will be able to move on with the project analysis. And you should be ready to answer these questions.

Yury Shamrei CEO, SumatoSoft

Technical expert/developer

coding a project

Technical experts don’t do any documentation, but it’s almost impossible to build a quality software product without consultation with technical experts, like SEO specialists, backend/ front-end developers. Their expertise is priceless and opens the door to build robust and effective systems. 

UX/UI designer (optional) 

Usually, projects require preparing prototypes and wireframes. Often this work can be done by the analyst, but sometimes the team also connects a separate UX/UI specialist. 

Software architect (optional)

While working with the most complex project it’s possible to attract software architects to make high-level decisions about the optimal stack of technologies to use in the development. 

Duration and Price of a Discovery Phase of a Project

Duration and Price of a Discovery Phase

These two parameters vary from project to project. A comprehensive project Discovery Phase for huge international companies can cost 100.000$+ and last for a year. After 9 years of experience in the software development market we can give the following figures: 

The duration: from 1 to 3 months. 

The price: from 15,000$ to 25,000$.

This is a reasonable price for high-quality research. We have to admit that lower values don’t imply the worse quality of research since there are a lot of variables that influence the discovery costs. But that means you take additional risks of possibly hiring unskilled specialists. Figures that exceed the values above are likely overpriced – ask such companies to explain the cost of their services. 

That is all for the first Part. Now you are aware of the key theoretical concepts about the Discovery Phase of a project. It’s time to set eyes on the discovery process itself. 

Part 2: How We Run a Discovery Phase For Our Clients

We describe all steps in the project Discovery phase and the tools we use in this section. However, every step should have some purpose, otherwise, its necessity is called into question. So we also mention the set of goals we want to achieve in every step. 

5 Steps in The Discovery Phase of a Project

5 steps in the discovery Phase of a Project - infographics

Step #1: The Initial interview. Requirements elicitation. 

interviewing

Goals: 

  • To gather high-level business requirements
  • To gather the info on the project from stakeholders
  • To make a project overview from a business point of view
  • To roughly evaluate the scope of work

To produce a relevant software solution we find out the initial business goals and high-level business requirements. All business requirements should be exhaustive, measurable, and prioritized. It’s also necessary to gather requirements and needs from every person who has an interest in the project, not only talk with top management. To make an optimal solution it’s also required to take into account the peculiarities of the industry where the solution will be implemented. 

Once the information on the project is gathered, we compile it in one place and analyze to make a primary overview of the project. Then we visually display all the collected data in the form of a mind map.

This step is not only about requirements identification. Most importantly, it helps to discuss business needs and goals and match them with the appropriate tech solution and implementation.

Yulia Kamotskaja, the Head of PM and BA.

Step #2: The discovery of users and their needs

Goals: 

  • To elicit users who will interact with the product
  • To elicit the challenges users want to solve
  • To validate the product-market fit
  • To check that there are no missed important requirements

Our business analyst identifies actors (people or systems) who will use this or that feature. We make a user profile that contains such information about users as gender, age, occupation, hobbies, challenges, etc. For example, any website has at least two actors: a non-registered user and an administrator. 

The final Discovery Phase report includes a set of key use cases. They are descriptions of the interactions between the system and the actors. For example, actions described as “adding an item to a customer’s order” are a use case. This step is important as it clearly explains the way real users are going to use the system. It leads to less vagueness in requirements development. 

One more staff to mention here is a customer journey map. It is a visual representation of the customer experience while communicating with the product. 

Step #3: Writing of the Vision and Scope document 

Writing of the Vision and Scope document

Goals: 

  • To capture the most important information in one place
  • To share the vision of the project across all stakeholders
  • To set the scope of work

In this step the SumatoSoft team makes a description of the optimal solution after brainstorming and several rounds of analysis. It breads the Vision and Scope document which becomes the basis of the project. It contains the description of goals, challenges, users, stakeholders, constraints, solution overview with key features, priorities, risks, and much more. 

This document establishes clear expectations, reduces risks, and becomes a guarantee that the final product will meet the business’s and user’s needs and requirements. 

Step #4: Prototyping 

Prototyping

Goals: 

  • Test the hypothesis about how to solve users’ challenges
  • Gather more accurate and detailed requirements

By creating wireframes and prototypes, our team allows users to interact with potential products and try to solve their challenges. After that, we can determine what aspects do their job and which ones need refining. 

Step #5: Documentation of Software Requirement Specification (SRS) 

Documentation of Software Requirement Specification (SRS)

 

Goals: 

  • To split use cases into components to develop
  • To reduce later redesign risks
  • To reduce the chances of requirement creep
  • To prepare the documents to make a precise budget and timeline estimation

The more detailed functional requirements and business rules are logically derived from the use cases. An example of such a functional requirement is “the system shall allow users to log in using one of the following social profiles: Facebook, Google+, LinkedIn”. Making a use-cases-based list of software requirements allows for fewer missed requirements. 

 

Tools We Use During a Discovery Phase Of a Project

There is an extensive set of tools that we actively use during the Discovery Phase:

  • Mind Map – a very useful tool to visually structure any set of ideas. We use it to find, describe, and examine some concepts and solutions.
  • User Story – one of the artifacts that are created during the Discovery Phase of a project. It explains how the system should work from the perspective of the end-user. QA engineers then use user stories to check the correctness of work after the development.
  • Use case model – helps us to illustrate how different types of users interact with the system to solve a problem.
  • BPMN Charts (business process modeling notation chart) – this tool can be used to display the process flow, the document flow, the status changes, and more. It’s an indispensable tool when we work with complex systems.
  • Request-Response Model – the title explains the value of this model. It reveals where and why the system gets/sends requests and how it can handle them.
  • Wireframes software

 

Part 3: What Clients Get as a Result of The Discovery Phase

discovery phase process

 

What are Deliverables Of the Discovery Phase Of a Project

Product Vision and Scope 

What is: A document with the description of high-level business requirements (goals, challenges, stakeholder profiles, success metrics), users portrait, project constraints, the vision of a future product, priorities of feature development, risks assessment. 

What for: Necessary to ensure the final product meets business needs. 

Software requirements specification (SRS) 

What is: A document with a nuanced description of the software product. It includes functional requirements, text about integration, recommended tech stack, described architecture, use cases. 

What for: The basis for SRS is the Product Vision and Scope and SRS, in turn, will become the main document during the coding and testing stages. 

Prototype designed at a high level 

What is: Visual user interfaces (quite often they are interactive) with the representation of all features of the product. 

What for: Prototype and SRS give a complete feel and understanding of the future product. 

Development roadmap with timeline and budget

product roadmap

What is: The final plan of the development is based on three previous deliverables. The budget and timeline are very precise and can be changed only in case of serious scope and requirement changes during the development. 

What for: That final deliverable gives a complete picture of how much effort, time, and money it will take to develop a project. 

With these discovery phase deliverables, a business can ask any company to build the product. You can also choose the SumatoSoft company because there is a bunch of reasons for that choice. 

 

Top 8 Benefits of a Discovery Phase

Benefit #1: Reduce development costs as much as 50% 

The project Discovery Phase decreases the chances to find a missed requirement during the development or after the release. The development of new vital features after the deployment can cost several times higher than it would cost at the beginning of the project. Besides, the Discovery Phase of a project helps to avoid expensive alterations of existing features. 

Benefit #2: Validate your business/product idea

The relevance of building a new piece of software or additional system is a big question. The Discovery Phase of a project identifies the product’s possibilities to satisfy users’ needs as well as to meet business needs. 

Benefit #3: Increase financing options 

The developed documentation, wireframes, market research increase the chances to attract financing. 

Benefit #4: Accurate estimation 

If a software development company makes a business proposal with timeframes and budget after the Discovery Phase of a project, the estimation is likely not to be altered later. But be sure that you choose the right software development company.  

Benefit #5: Create a shared vision among all stakeholders

A vision of a final solution is stored in documents and everybody can view it. It significantly reduces the odds of confusion within the team on what they build.

Benefit #6: Cut time-to-market by 20% 

As a result of the precise budget, timeframe, and clearly defined amount of work the time-to-market is cut up to 20%.  

Cut time-to-market by 20%

Benefit #7: Create a great user experience 

The team forms the most optimal solution to create a user experience so they would love to use the product. 

Benefit #8: Improve requirement management

The BA watches over the process of translating business requirements through functional requirements to a solution specification so that every requirement is understood, interpreted, and realized by all parties the right way. 

 

SumatoSoft Is a Reliable Partner For to Run the Discovery Phase 

Process of Business Analysis

Every project we undertake starts from a nuanced business analysis. We have more than 100 successful projects in various industries like eCommerce, Elearning, Finance, Real Estate, Transport, Travel, and more. After more than 9 years of work, we have established a flexible Discovery process for different time and budget limitations. 

  • Our clients’ satisfaction rate is 98% thanks to our strong commitment to deadlines and their needs
  • We use the latest knowledge about business analysis in our work
  • We have a deep expertise that allows us to develop the right solutions
  • We are a member of The Council for Inclusive Capitalism
  • We are recognized as top software developers by leading analyst agencies like techreviewer, clutch, goodfirms
  • We are ready to offer your excellent results for a reasonable price
  • We are the right team for your project

Get in touch with us for a free consultation. Let’s build a new product together. 

Final words

The Discovery Phase of a project helps businesses and developers to make documents that become a guiding start during the development. There are numerous benefits this phase brings as well as it significantly reduces risks and uncertainty in the project. 

Unfortunately, the DIscovery Phase does not guarantee that the project will be successful. But the truth is that nothing can guarantee this. And yet, running a discovery phase of a project will significantly increase the chances of success and that the project will be delivered on time and within budget, and will also bring real value to final users.

Thanks for reading!