Get the most recent info and news about Initialized on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Initialized

initialized

Dawn

Mission

Asteroid mining

Hardware made in Christchurch will be used in the first deep-space mining mission. And it’s one that will help shape things back on Earth. Palladium, used in the manufacture of emission-reducing catalytic converters for cars,

Deep-space mining: Dawn Aerospace delivers propulsion system for AstroForge’s first asteroid mission

https://www.bing.com/th?id=ODF.h5PSiTwmPhAF0S_Ew_4zIg&pid=news

The New Zealand Herald

Alexis Ohanian

Alexis Ohanian is a billionaire from the United States, well-known as the co-founder of Reddit, one of the internet's most popular social media and discussion platforms. Apart from Reddit, Alexis co-founded a venture capital firm called Initialized Capital in 2011.

https://www.bing.com/th?id=OVFT.xUXcur_6Tc02U9FPVS1Hay&pid=News

Understanding

Valuation

Understanding Alexis Ohanian's net worth: What is his valuation?

https://www.bing.com/th?id=ODF.jhdmyoRr1rgT_o6qPNDMNA&pid=news

Briefly on MSN.com

The Vanguard Group

Essentially, Valorant Vanguard Not initialized error occurs after a player has stopped the game for a while and then attempts to resume it. Quit and Relaunch Valorant ...

Fix Valorant Vanguard Not initialized error

TWCN Tech News

Disk image

Microsoft Windows

It’s always a good idea to have an Image Backup of your OS. So, if there’s any even of misfortune, you don’t end up losing your data but can restore it fully from Repair Disc or an external ...

Couldn’t Mount File, The disk image isn’t initialized error in Windows 11/10

Spelling of disc

If you have installed a new internal or external hard drive or SSD, and its status on the left side of the Disk Management Tool displays Disk 1, Unknown Not Initialized then it means that Windows ...

Disk Unknown Not Initialized, Can’t initialize disk in Windows 11/10

Ending The Crypto Winter with Garry Tan and Brett Gibson of Initialized Capital

In our current era, technology is advancing with unparalleled speed and the law is striving to keep pace. The interface between law and technology has become a challenging environment in which up-to-date difficulties and possibilities continuously appear. As our surroundings become even more digitized, the legal system must adjust to secure fairness, protection, and responsibility. Thus, in this article, we will analyze some of the most significant issues at the convergence of law and technology and the achievable solutions that can form the foundation for a mutual and cohesive connection. Protection of Data in the Digital Era In this digital age, consumers are finding it increasingly challenging to stay in control of their personal information. With the rapid development of digital technology, companies are empowered to collect and store a wide range of data obtained from consumers around the world. This data can be used to gain insight into consumers’ behavior, preferences, and interests. Such power grants tremendous opportunities for companies to sharpen their marketing strategies and enhance customer experience. Nevertheless, this also presents a serious threat to privacy and security. The modern world is characterized by an unprecedented scaling up of digital capabilities in data storage and data processing, improving the efficiency of cross-border and international trade. Furthermore, advances in data analytics – such as predictive analytics, machine learning, and artificial intelligence techniques – allow marketers to survey vast amounts of behavioral information and use it to their advantage. Despite the increase in efficiency, all this data-driven activity also risks carrying serious repercussions such as identity theft, discrimination, or misuse of personal information. It is, therefore, of the utmost importance to ensure the protection of individuals’ data Privacy and security. Digital organizations must comply with the applicable legal and regulatory restrictions on data collection. Moreover, the use of cryptography, authentication, and authorization techniques further enables them to keep customers’ data safe. Further, individuals should take the proactive step to manage and regulate how and when their personal information is being used. To sum up, the digital age has ushered in a new frontier for businesses to expand their reach and reconfigure their operations. However, it is essential to strike an appropriate balance between such opportunities and managing privacy concerns. Organizations must strive to protect consumers’ data and people must be well-informed of their right to privacy. This way, we can achieve a safe and secure digital environment that benefits both individuals and the society at large. Privacy has been brought to the forefront as we have entered the digital era. With the emergence of social media, the increase of technological products, and the storage of immense amounts of private information, people's seclusion is more vulnerable than ever. Laws have had to face the challenge of upholding personal security while still permitting tech advancement. The General Data Protection Regulation ( ) of the European Union is a superb exemplar of how the law and technology connect to defend privacy. GDPR has instituted a universal model of data protection by stipulating that companies must secure unmistakable permission for the gathering of information and granting individuals the authority to access and wipe out their information. Despite its considerable progress in safeguarding privacy, there are continuous dialogues concerning the enforcement of the regulation and whether analogous regulations should be embraced in other countries. GDPR In the United States, a clash around data confidentiality persists, with many states adopting their own information safeguard statutes. The most distinguished of these is the (CCPA), which equips locals with the ability to direct their private data. Moreover, the country is additionally scrutinizing the possibility of a national data confidentiality statute, showcasing the never-ending struggle between technological advancement and statutory shelter. California Consumer Privacy Act Cybersecurity and hacking are two concepts that have become increasingly intertwined in the modern era. With the increasing prevalence of sensitive digital data, the ability to protect it is increasingly becoming a primary concern. As the number of incidences of cybersecurity breaches continues to rise, the need to protect vulnerable devices has become a critical issue. In order for organizations to protect themselves from malicious cyber-attacks, they must understand how hackers gain access to systems and take steps to prevent or mitigate any potential threats. Hacking is a form of computer intrusion in which an attacker gains access to a system or network without legal authorization. Hackers may use any means available to exploit software and hardware vulnerabilities for their own financial, political, or personal gain. Common tactics involve using malicious software, such as viruses, worms, or Trojan horses, to gain access to computers or networks. In addition, many hackers leverage social engineering techniques to access sensitive information and data. The world of cybersecurity has become increasingly complex as the sophistication and scale of cyber-attacks continue to expand. Organizations must ensure they have adequate protection in place to ward off, or at least curtail, any malicious activity. This includes deploying robust software to detect malicious code, investing in training programs for personnel, and staying abreast of the latest developments in cybersecurity. Ultimately, reducing the risk of cyber-attacks requires a combination of technical expertise and vigilance. As the trend of cyber-attacks continues to grow, the need to protect digital data and sensitive information from hackers is essential. To ensure that systems are secure, organizations must develop a comprehensive strategy that comprises equipment and tools, personnel training, and an up-to-date understanding of the threats posed by hackers and other cybercriminals. As the technology frontier evolves, cybersecurity measures must continuously evolve to safeguard against the malicious activities of cyber miscreants. In this digital age, cyber safety has become essential for governments, commercial entities, and people alike. Cyber-attacks and data breaches can cause tremendous harm, hence why legislation is being adopted to deal with such issues. Technology is now deeply embedded in the fabric of our everyday lives, making these safety concerns very pertinent. In the United States, the Computer Fraud and Abuse Act (CFAA) is a crucial statute within the field of cyber security. Despite this, it has received criticism for its imprecise phrasing and stern sanctions. Scholars of the law and tech authorities are calling for modification that would bring more understanding while still keeping the need for a way of stronger dissuasion against unauthorized users. Global initiatives to battle cybercrime and set standards for states' behavior in the cyber realm have seen increasing progress. on the International Law Applicable to Cyber Warfare are a few illustrations of nations' communal efforts to construct a legal configuration for the virtual world. The Budapest Convention on Cybercrime and the Tallinn Manual The digital era has drastically altered the way in which intellectual property is managed and protected. Such changes have placed an ever-increasing burden on copyright holders, who must now invest considerable resources in order to secure and safeguard their creations. To address this, a variety of approaches have been implemented, from strengthened legislation and prosecutorial action to advancements in technology and utilization of digital rights management systems. However, one of the biggest challenges associated with intellectual property in the digital age lies in the proclivity to quickly and easily copy and distribute digital files. Attempts to curb this phenomenon have proven to be largely unsuccessful. It is apparent that further innovative approaches must be developed in order to protect intellectual property while offering adequate access for legitimate users. The onus of maintaining the integrity of intellectual property ultimately lies with legal institutions. The implementation of legal systems that can accurately and effectively monitor and control the usage of copyrighted material is essential, and their strongest asset is their ability to swiftly prosecute offenders. Additionally, the accessibility of up-to-date information and tools is necessary in order to assist copyright holders in protecting and enforcing their rights. In conclusion, the digital era has necessitated the need for a thorough overhaul of legal institutions that deal with the management and protection of intellectual property. This issue is further complicated by the ease with which digital files can be copied and distributed, making any legal system more difficult to enforce. Solutions to this problem include stronger legislative support, increased prosecutorial action, and tools to aid in the monitoring and enforcement of intellectual property. It is crucial that stakeholders continue to explore innovative ways of safeguarding intellectual property so as to protect the rights of creators and facilitate the availability of legitimate content. The extensive dissemination of digital material has entirely altered the production, distribution, and security of intellectual property. Copyright legislation has uniquely been impacted by the far-sweeping capabilities of the web and the effortlessness of replicating and circulating content. Fair usage, digital rights administration, and the responsiveness of internet services are some difficult questions that have been raised. In recent years, a conflict between tech powerhouses and content producers over the use of copyrighted components has been one of the most noteworthy legal battles. Platforms, such as YouTube and Twitch, have employed automated content identification technologies in an attempt to modulate copyright infringement. However, these systems have encountered criticism for their excessive aggressiveness, giving rise to erroneous removals. The Digital Millennium Copyright Act (DMCA) in the USA has come under scrutiny due to the discrepancies it poses. Exigencies for retrofitting the legislation with a view to addressing the difficulties of the digitized age, and protecting the privileges of those who produce content, are being advocated by both learned legalists and knowledgeable technologists. The advent of Artificial Intelligence (AI) has revolutionized the way corporations manage their business operations. With the help of AI, organizations now have the capability to automate tedious and difficult tasks, manage vast amounts of data in a variety of contexts, implement predictive analytics, and provide customers with personalized experiences. However, with the increasing reliance on AI, questions have been raised regarding the potential for legal and ethical liability. As AI technology continues to proliferate in the realms of business and public administration, it is essential to understand the associated legal liabilities. To this end, there have been several studies examining the role of AI in legal responsibility. These have highlighted that AI-enabled systems should be regulated both in terms of their usage as well as the manner in which they are created and maintained. Additionally, questions of ethical culpability have been raised with regard to the potential for AI to cross the boundaries of ethical practices or accepted standards. Ultimately, when AI technology fails to produce outcomes that are ethically satisfactory, the question arises as to whether its creators, owners, or operators should bear the responsibility. Thus, it is essential to have clear guidelines and procedures in place to accurately assess and assign legal liability as well as one's responsibilities from an ethical standpoint. At present, there is a distinct lack of consensus on the issue of , but it is likely that further investigations and developments in the field will provide clearer definitions in the future. AI liability The growth of artificial intelligence (AI) has spawned novel issues related to liability in cases of error. Autonomous vehicles, AI-driven medical prognosis, and predictive algorithms employed in the areas of financial services and policing have all sparked inquiries regarding responsibility and accountability. Who is responsible when an AI system makes a misstep—the creator, the user, or the machine itself? Legal systems across the world are engaged in grappling with these queries. Examples like Germany demonstrate that certain nations have already established legislation obligating coders to supply explanations for artificial intelligence decisions. Moreover, a number of countries are analyzing the notion of "robot rights," pondering if AI frameworks ought to be granted legal personality or responsibility. These are knotty matters that necessitate a judicious balance between fostering AI advancement and guaranteeing liability. Authoritative frameworks capable of addressing the remarkable difficulties AI embodies will be indispensable in the ensuing years. Blockchain technology and Smart Contracts are two of the most revolutionary concepts in recent times. These innovative solutions have revolutionized the way information is stored, transmitted, and shared. In essence, blockchain provides a distributed ledger of records consisting of databases or public ledgers, which are secured by cryptography, stored on the customer's system, and initialized by consensus protocols that are shared among participants. Smart Contracts offer digital rules and agreements that are executed automatically when predetermined conditions are met. By leveraging the power of blockchain and Smart Contracts, data remains secure, transparent, and immutable.  Consequently, trading partners can trust one another without needing an intermediary or expensive third-party validation. Smart Contracts also give rise to numerous possibilities such as immutable contracts, audit trails, identity management, safe asset transfer, and the automation of legal documents. All of this indicates that blockchain and Smart Contracts are viable solutions for the storage, transmission, and sharing of information securely, transparently, and efficiently. Blockchain technology and smart contracts are transforming the means by which we transact and administer bargains. These tools guarantee increased transparency, security, and productivity. Nevertheless, they also rouse inquiries about the legal traceability of smart contracts and how blockchain archives can be relied on as evidence in lawful disputes. The acknowledgment of in the legal framework is still in flux, yet there is a growing agreement that these technologies can make the directive of the law more effective and eliminate the need for middlemen. Some countries have already made advancements to specify the legal situation of smart contracts, while the future progress of this technology is being carefully observed by others. smart contracts and blockchain-based transactions The supervision of newly arising technologies is an issue of ongoing concern. Governments need to create appropriate regulations and mechanisms in order to keep up with the constant introduction of advanced solutions. This requires careful consideration of the potential risks associated with embracing these technologies, while also acknowledging the potential for them to improve society. The development of appropriate legislation for emerging technologies is an ever-evolving challenge. Policymakers must carefully take into account the scientific, ethical, and legal ramifications of introducing new solutions. They must assess the potential benefits within the wider context of society and weigh up the possible risks that could be incurred. It is only through robust regulation that equal rewards can be gained. Ensuring the successful implementation of regulations governing emerging technologies is also essential. The need for sufficient monitoring and enforcement cannot be understated; any tentative steps taken in this area should be met with vigorous oversight. Promoting public awareness of any changes to the would also be beneficial, as it ensures that individuals and organizations are kept abreast of the latest developments. legal landscape In conclusion, it is clear that regulating emerging technologies will remain an ongoing challenge and a complex and multi-disciplinary approach is required in order to ensure compliance. Governments must assess the risks and benefits of any solution prior to implementation, while also providing ample resources for monitoring and enforcement. The implementation of these measures will help ensure that any potential rewards are realized in a fair and responsible fashion. Up-and-coming technologies such as biotechnology, quantum computing, and artificial general intelligence are on the horizon, which poses fresh trials and chances. Lawmaking entities must try to anticipate the repercussions of these technologies and commit to formulating regulations proactively in order to govern their exploitation. Ethical issues, safety, and potential for abuse are all consequences to bring into account. As an example, genetic alteration technologies such as CRISPR-Cas9 have the potential to revolutionize healthcare, yet they raise disquiets about inevitable effects and moral quandaries. Quantum computing's ability to surpass existing cryptography regulations necessitates sound cyber defense rules, and AGI's likely sway on the workforce and the global population entails complete policy frameworks. To put it in a nutshell, the relationship between law and technology is dynamic and incessantly transforming. As our planet is continually being technologically transformed, the legal climate has to reshape itself to ensure the safeguarding of individual liberties, enhance cybersecurity, endorse innovation, and ensure accountability. Technological developments deliver numerous opportunities and obstacles and necessitate an adaptive legal posture that can properly juggle the significance of growth and structures required to help foster social values and aspirations. In the forthcoming, the amalgamation of law and technology will keep on evolving and the legal domain will have to juggle with these continual changes.

Legal Strategies for Navigating the Information Age 

A monorepo is a repository containing multiple related resources managed from an individual repository. Using , we can build dynamic component libraries that numerous applications can consume, all retained in one version-controlled repository. NPM workspaces Introduction Monorepo's have been gaining traction over the years. Having worked with them for over a year in production environments, I can say one thing: ! they beat git submodules A typical monorepo will contain multiple packages and projects that are closely related. We can work more efficiently using a monorepo in a way that allows us to move away from: initializing git submodules (a repo within a repo) linking local packages from other locations on the disk that must be updated and installed. NPM supports , which effectively allows for a monorepo structure. You'll need to use NPM v7 and above to set up a Recently, I embarked on building a suite of components for a NextJS project. I wanted to ensure that I could actively develop components (facilitated by Storybook) so that my NextJS projects could consume those components. workspaces workspace. Historically, have always supported a folder. However, NextJS restricts this to the application itself. I aim to treat my component library like any other 3rd-party library I'd want to import into my projects. An architecture of this manner is easily achievable using a mono repo. NextJS projects components Initialise Project Structure Our first step is to set up a project structure supporting a monorepo. Create a folder where your monorepo can live: mkdir my-monorepo && cd my-monorepo Great. Our next step is to create a file. We can bootstrap one quickly by running the following: package.json npm init -y That should produce the following output: {
  "name": "my-monorepo",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC"
} Let's add some items to our before installing dependencies. We'll need to add a key. Doing so informs NPM where our projects and packages sit. package.json workspaces NPM comes with a nifty command for adding workspaces; run the below commands and follow the instruction wizard that each command outputs: npm init -w ./packages/component-library
npm init -w ./projects/monorepo-site Executing the above will run for you as well. npm install At this point, we will see our first fundamental differences between a traditional repo and a monorepo: A exists in the root and within every "workspace." You may notice that there is only one occurrence of and Now, all workspace dependencies get managed from the root folder. package.json node_modules package-lock.json. Next up, we'll look into how to install workspace-specific dependencies. Install dependencies When installing package or project dependencies, we can still leverage - however, this needs to be run from the root folder and requires that we pass a flag to the command. Let's run through . npm install -w installing NextJS npm install --save next react react-dom -w monorepo-site Run the command above from the of your project folder, where and the can be found. The only thing to call out here is that the value passed to must match the field of one of your or package.json. In this example, the field of is root node_modules package-lock.json -w name project packages name projects/monorepo-site/package.json monorepo-site. If all was successful, you should see the dependencies added to projects/monorepo-site/package.json. "dependencies": {
    "next": "^13.0.6",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
} Repeat this process for any necessary dependencies in as well. packages/component-library Setup Components and StoryBook Please note that this is not a tutorial on how to get set up with Storybook. Let's take some steps to get Storybook set up correctly. We'll also create a dummy component to verify that our setup works. As StoryBook isn't a dependency of either or we can install it in the root of our monorepo: packages projects, npm install --save-dev @storybook/react @storybook/manager-webpack5 @storybook/builder-webpack5 @storybook/addon-postcss Let's also add the build commands to the root monorepo package.json: "storybook": "start-storybook -p 6006",
"build-storybook": "build-storybook" Next, we'll need to create the folder; let's do this and add it to the root of the monorepo. You'll want to add two files to this folder: .storybook main.js preview.js is where we configure StoryBook's settings: main.js module.exports = {
    "stories": [
        "../packages/component-library/**/*.stories.jsx",
    ],
    "addons": [
        {
            name: '@storybook/addon-postcss',
            options: {
                styleLoaderOptions: {},
                cssLoaderOptions: {
                    modules: true,
                    sourceMap: true,
                    importLoaders: 1,
                },
                postcssLoaderOptions: {
                    implementation: require('postcss'),
                },
            },
        }
    ],
    "framework": "@storybook/react",
    "core": {
        "builder": "@storybook/builder-webpack5"
    }
} In our file above - we tell StoryBook where to look for component stories. We also include the plugin that supports PostCSS. The extra options you see listed above enabled PostCSS Modules. The last two keys: and allow us to configure StoryBook to use Webpack v5. main.js @storybook/addon-postcss framework core, In add the following: preview.js, export const decorators = [
    (Story, context) => {
        return (
            <div style={{ padding: '1rem', display: 'flex', justifyContent: 'center' }}>
                <div>
                    <Story {...context} />
                </div>
            </div>
        );
    }
]; The file allows us to customize the appearance of stories without affecting the component logic itself. Hence, the name "decorator". I've just added some basic styling here to center the button. preview.js Next, we need to flesh out our component. In add a new folder called ; in that folder, add the following files: Button package/component-library, Button Button.module.css - handles the styling of the button Button.stories.jsx - handles the button story Button.jsx - the button component itself You can find the contents of these files in the repo. Great, we need to see if we can import our component into NextJS. Setup a NextJS project We need to return to NextJS quickly to tie everything together meaningfully. First, add a folder to the and the scripts needed in to build NextJS. pages NextJS site package.json To add the scripts, go to and replace the current field with: projects/monorepo-site/package.json scripts "scripts": {
	"dev": "next dev",
	"build": "next build",
	"start": "next start",
	"lint": "next lint"
} In the folder, add an file with the following contents: pages index.js const Home = () => {
	return (
		<main>
			<h1>Hello! This is a NextJS + StoryBook Monorepo</h1>
		</main>
	)
}

export default Home Add the Component to NextJS Now, it's time to import our component into NextJS. Let's import the button into : projects/monorepo-site/pages/index.js import Button from '../../../packages/component-library/Button/Button.jsx' When you run , you'll likely run into an error. NextJS does not transpile ES6 JavaScript from or any other local folder outside its reach. npm run dev node_modules To get around this problem, configure a property in called : next.config.js transpileModules export const nextConfig = {
	transpileModules: ['component-library']
} Note that the name, is passed, not the path to the folder on the disk. You'll need to restart your dev server. workspace component-library, Your custom Button component now lives in NextJS and StoryBook and can be iterated upon and tracked in the repo! You may run into trouble with NextJS asking for React v18 if you use NextJS 13. This tutorial was written using NextJS v12 and React v17.0.2 Additional Scripts for Convenience To run our build commands, we'd have to into every or . Doing so can be time-consuming, so let's add the following to the found in the root: cd project package scripts package.json "scripts": {
	"build": "npm run build --workspaces --if-present",
	"dev:monorepo-site": "npm run dev -w monorepo-site",
} Let's run through these two commands as they differ slightly. Running in the root will allow us to fire off individual scripts in all workspaces. If the task isn't in a or package.json, it will simply skip it. npm run build build build package project If, at some point, this particular example scaled to have three production sites, all with a command, we could run from the root, and for each workspace, the build task will execute. Pretty nifty! build npm run build is slightly different - this command targets one workspace and fires off the defined within that workspace (as long as it exists). Doing so allows us to spin up the server for from the root without navigating to the folder. npm run dev:monorepo-site script dev monorepo-site Conclusion Let's review where we're at: We initialized a monorepo structure using in NPM workspaces Set up a component library and production site with StoryBook and NextJS. Added scripts that will make our developer experience more accessible to manage. All our dependencies get managed from the top level, and we do not have to pull in other repos or git submodules. At this point, we could easily add a new site project or extend our component library. We could also add other that may deal with custom server functionality, CMS integrations, or API support. The possibilities are endless. Now it's time for you to try! packages Also published . here

Mastering Monorepos: Organizing Component NextJS Libraries & Projects with NPM Workspaces

Introduction In modern web development, the boundaries between classic and web applications are blurring every day. Today, we can create not only interactive websites but also full-fledged games right in the browser. One of the tools that makes this possible is the library - a powerful tool for creating 3D graphics based on using technology. React Three Fiber Three.js React In today's article, we will implement: weapon aiming animation; flash animation when firing; add a sound effect when firing a gun. Repository on GitHub https://youtu.be/fSihvQn_qWQ?embedable=true https://codesandbox.io/p/github/JI0PATA/fps-game?embedable=true Minor edits Before we start, let's create a new images folder for images in the assets folder. And move the image of the floor surface to this folder. Also, change the path to the image in the file. Ground.jsx Section code Aiming mechanics As in most shooters, aiming is activated by right-clicking. But users can reassign this button to any other at any time in the game settings. Therefore, we will not set the condition of pressing this key directly in the code but will implement a separate config where we will set the control. In it is already possible to create such a config without additional libraries. To do this, you need to create a file in the root of the project. Then, it is in the format that we can set environment variables that we can use anywhere in our project. React(Vite), .env VITE_*** In the configuration file, let's add two variables that will contain the codes of mouse button presses. Namely, the code for the mouse button to activate firing and also for aiming. .env Now, we need to rework the mouse button logic so that different actions are activated when different buttons are pressed. But first, we need to fix some incorrect behavior when intercepting the mouse cursor on the canvas. At the moment, clicking the mouse on the screen immediately triggers a shot action, which looks a bit odd. So we'll add logic that until the cursor is intercepted by the application, then no click events will occur. Now, we'll use the library to store the global state of . In the file, we'll add the state and add event handlers for locking and unlocking the cursor. Zustand App.jsx In the file, we will add new logic that will differentiate between mouse keys pressed and also take into account the state of the intercepted cursor. Weapon.jsx Let's create a function . Inside, we will determine the current state of the intercepted cursor, and if the cursor has not been intercepted yet, we will not perform any actions. We also need to import from config the values for the mouse keys that activate the firing or aiming mode. mouseButtonHandler .env Let's also change the logic of the event handlers when pressing and releasing mouse keys. Now, let's directly implement the aiming animation. First, let's add a new state, to store the aiming state. useAimingStore, Let's add a variable to be able to change the aiming state. And in the function, where we previously left empty space for the button, we add a state change. mouseButtonHandler AIM_BUTTON Let's go to the file and do the implementation inside it. Player.jsx Firstly, we need to import the states from the file. Also, move the constant to the root of the file. useAimingStore Weapon.jsx easing Let's add the state for further use in the file. isAiming To save the state of the animation, let's add two states: aiming animation and returning to the original state. Now, let's create the function, which will describe both states of the aiming animation. initAimingAnimation In order for this animation to run, it is necessary to call the function when initializing the application. This is exactly when the object with the weapon model inside is ready for interaction. initAimingAnimation When changing the state, it is necessary to trigger either the aiming animation or the weapon return to the initial position. For this purpose, let's add , within which one or another logic will be triggered according to the condition. So, for example, when starting the aiming process, it will be necessary to stop the "wiggle" animation and then start the aiming animation. When the mouse button is released, the animation of returning the weapon to the initial position is triggered, and when the event is triggered, the "wiggle" animation is re-run. isAiming useEffect onComplete But now, when the application is initialized, the animation starts up, and it looks like the player was aiming and then exits the aiming mode. This happens because, by default, is set to , and the "or" branch in the condition is immediately triggered during initialization. You can solve this by fixing the default value to and then modifying the condition by adding a specific value to the condition. isAiming false null So now we have an aiming animation when the right mouse button is clicked and an exit from this mode when it is released. Section code Refactoring the recoil animation Before we get to the next part of our article, let's do some refactoring of the animation implementation. In the file, let's change the function name from to . And also replace this function name in other places. Player.jsx setAnimationParams setSwayingAnimationParams And from the function, we will remove the constant because earlier we moved it to the root of the file. initSwayingObjectAnimation easing Let's move on to fixing the Weapon.jsx file. Change the value for to 50. recoilDuration Let's remove for unnecessary. Instead, let's now add . recoilBackAnimation isRecoilAnimationFinished For the function, let's add a default value for the parameter. generateNewPositionOfRecoil currentPosition In the function, let's remove the constant for uselessness. initRecoilAnimation initialPosition For Tween-animation, we will rework the logic, making it automatically-return to the initial position from which the animation started. We will also remove the return animation . twRecoilBackAnimation Let's rework by splitting it into 2 different functions. The first will initialize the animation, and the second will run the weapon recoil animation. useEffect Section code Animation of the flash when shooting Now, let's implement the flash display when the weapon is fired. In the file import the function. And also, load the flash image into . Weapon.jsx useLoader assets/images In the component, import this image as . FlashShoot Next, let's use the function to load this image into the scene. We will also add a state to save the . useLoader flashAnimation Let's create a new state to smoothly change the transparency of the flash. We will also create a new function , in which we will describe the animation sequence. And after that, we'll to initialize the animation. flashOpacity initFlashAnimation useEffect Now, we need to display this image on the stage at the same level as the weapon model, setting the location so that the image is located directly on the end of the muzzle of the weapon. And finally, let's add a call to the startShooting function for animation at each shot. Section code Adding the sound of a gunshot Let's add the prepared sound file to the folder. assets/sounds Import it into a file. Using we can add a sound file for the current page (not for the scene). HTMLAudioElement, When the function is called, we launch the given audio file. For several shots, the audio files to be launched will start and overlap with each other. And at the end just stop playing. startShooting Section code Conclusion In this article, we have added an aiming animation, a flash animation when shooting, and a sound effect when shooting. In the next article, we will continue to refine our game by adding new functionality. Thanks for reading, and I will be glad to respond to your comments! Also published . here

Creating Your Own 3D Shooter Using the React and Three.js Stack — Part 2

The beauty of any web application is its responsiveness to users' actions. Therefore knowing how to build a dynamic and interactive app as a developer is crucial. In this article, we are going to look into the concept of state in React, and how it makes React components dynamic and interactive. If you're new to React, don't worry! We are going to explain the concept step by step. Prerequisites Basic understanding of React Understanding Component and Data Components in React are like building blocks; they can range from a simple button to a complex web page. So it's these building blocks that get compiled together to become a fully functional web application. React components can either be a class component or a functional component. However, we will only be focusing on functional components. What is State In React, is like a safebox inside a component that holds all the information about the component. state Think of it as the specific memory for that component. The information could be emails, usernames, images, etc. . Importance of State in React Components React uses a building block system called "component-based architecture." Imagine the use of bricks for building a house. Each brick is the component and the house is the app built by React. Each brick now has its state - a safebox for storing information or data. State is crucial to each React component, as it helps the component inform React that the information or data it possesses can change. This helps developers to store information in components and display it as needed. For example, it can help React keep track of the number of times a button is clicked and displayed on every change. How State make Components dynamic and interact. Since the state acts as a form of memory for each component, enabling them to respond to every action or input by the user. The component response is based on the information stored in its memory. Such response(s) can be triggered by some events or user actions on the React app. State empowers React to change and update the display or behavior of each component. The dynamic and interactive properties of the React app are therefore dependent on the capability of each component to remember the data they have and the changes affecting such data. It's like thinking of changing the color of a building, and the way of doing that is by instructing each brick to achieve this. A brief explanation of Props. Props, short for properties, facilitate the communication between different React components. By enabling the passing of data or information across components. The data are passed as arguments. Similar to the use of attributes in HTML or the passing of arguments in javascript functions. Props in react move unidirectionally from the parent to the child component. The child component cannot modify the passed data. Using Props is also important in making components reusable and interactive. Differences between State and Props. The difference is as follows; Management Manages data only within a component. State: Manages data passed from parent to child component; this enables communication between them. Props: Scope and Access The data is only available and accessible to the component within which it has been declared. It cannot be accessible by another component unless passed as props. So the data is private. State: Allows only the availability of data in a parent-to-child direction. Props: Mutability State is mutable. The data can be modified by the component, and this causes React to be re-rendered. State: Props are read-only and not mutable. Once the child component receives the data, it cannot modify it. Props: React Hooks and State React has several hooks, but we are only going to talk about the hook, which helps in the management of state in React. useState So, what are hooks? Hooks are functions used by React functional components. They are used to access and manage state and react lifecycle behaviors in React functional components effortlessly and more simply. So basically, they allow you to "hook into '' React state and lifecycle in functional components without writing class components. The useState hook helps access and manage state in functional components. This hook takes an initial value and then returns an array with two elements that is, the current state and the " function that updates the state. setState" Let's look at an example to explain state and the use of the useState hook. import React, { useState } from 'react';

function Counter() {

// Declare a state variable named "count" with an initial value of 0

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

      return (

        <div>

          <p>Count: {count}</p>

          <button onClick={() => setCount(count + 1)}>Increment</button>

        </div>

      );

   } Here, in the example we see the counter state is initialized to by " " and then the " " function is provided alongside to update the state, thus causing React to re-render with the updated count displayed. Therefore, whenever the button is clicked the state gets updated and the new count is displayed. 0 count setCount Conclusion. In conclusion, state plays a pivotal role in the response of react components to users' events or activities. Thus making React applications more responsive. This helps react developers manage data or information and also display them. We made a distinction between state and props. We got to understand that State is private to each component and the data is personal and cannot be passed to other components except as props. While props can be passed to another component, that is the child component(s). We also got introduced to how to manage state in React by using React hooks - the useState, which offers a more easy approach to handling state in functional components, better than the class components. In essence, understanding of state empowers React developers to create dynamic and interactive web applications. Don't worry. As you drive deeper into the world of React and build more on your knowledge, a better understanding of state will enable you to build responsive interfaces. There are other ways to manage state in React and they include using the useReducer hooks or a third-party library the Redux Toolkit. NB: The complexity of our app determines how to manage the state. Happy coding champs! Also published . here

Why State Matters: Building Dynamic Web Applications in React

Hello World! As a developer, we are using Git commands every day. Here is a list of top Git commands that you should know. Before jumping into the commands, let's see an overview of Git. What is Git? Git is an open-source distributed version control system. In simple words, it is a DevOps tool to manage source code. With Git, we can track the history of the code base, and it also allows multiple people to work on the same code base. Git Commands 1. Init The init command is used to initialize a repository. Executing this command will create an empty repository in the location where executed, which we can use for version control. Syntax: git init To execute this command, we need to move to the location where we want to initialize the git repository. For example, if I need to initialize a repository in the path , then I'll need to move to that particular path and execute the command. /home/sriram/projects/app1 cd /home/sriram/projects/app1
git init 2. Clone The clone command is used to clone any remote repository into our local machine. Suppose we have hosted our in any remote git service provider like GitHub and we want to clone it in some other local machine, then we use the clone command app1 Syntax: git clone <repository> Example: git clone https://github.com/sriram23/app1.git 3. Remote The Git Remote command is used to manage the set of tracked remote repositories. Suppose we have initialized an empty git repository in our local machine, and we need to push it to a remote repo. To specify which remote repository to push, we will be using the remote command. Syntax: git remote -v # To list the remote repositories that are being tracked
git remote add [name] [repository] # To add a new remote repository
git remote rename [old] [new] # To rename a remote
git remote set-url [repo url] # To update a repo url Example: 4. Branch The branch command is used to create, list, and delete branches. The branch is nothing but an independent line of development, which is then can be merged with the master code through a Pull request / Merge request. Syntax: git branch # List the local branches
git branch <branch name> # Creates a new branch
git branch -d <branch name> # Delete branch post pushing to the upstream (Remote)
git branch -D <branch name> # Delete branch forcefully, even if not pushed to upstream Example: 5. Checkout The checkout command is used to switch from one branch to another. Syntax: git checkout <branch> # Checkout to another branch
git checkout -b <branch> # Will create a new branch and will checkout
git checkout -B <branch> # Will create a new branch if doesn't exist. If exsits, will be reset and checked out. Example: 6. Add The add command is used to stage the file contents, which is nothing but adding changes to the index. Syntax: git add . # To stage all the changes.
git add <file1, file2, ... filen> # To stage specific files. 7. Commit The commit command is used to record the changes to the repository. Syntax: git commit -m <message> Example: git commit -m "Fixed issues with responsiveness" 8. Status The status command is used to get the status of the working tree. Syntax: git status Example: 9. Push The push command is used to push our local commits to the remote repositories. Syntax: git push <remote name> <branch> Example: git push origin master 10. Pull The pull command is used to fetch the changes from another branch Syntax: git pull <options> Example: git pull origin master 11. Reset The Reset command is used to reset the current head to a specific commit. There are two commonly used modes for resetting. They are the soft reset and hard reset. The soft reset would stage the recent stage and move the head to a specific commit. The hard reset would ignore the recent stage and move the head to a specific commit. Syntax: git reset --soft <commit hash> # Soft reset
git reset --hard <commit hash> # Hard reset 12. Revert The Revert command is similar to the Reset command. The difference is in Reset; the head is moved to the specified commit. In case of the revert, a new commit will be created with the changes of the specified commit. In other words, a new commit will be created to revert the changes of the specified commit. Syntax: git revert <commit hash> 13. Stash The Stash is a command used to store the local modification in a separate space. The stashed changes can be retrieved later. Syntax: git stash # Will store all the changes, except the untracked files
git stash --include-untracked # Will store all the changes including untracked files
git stash list # To list the stashes in the repo
git stash clear # To clear the stored stashes
git stash save <message> # To stash with a message.
git stash apply <stash> # To apply a specific stash. Will apply stored changes to the file
git stash pop # Applies the latest stash and remove it from stash list Example: 14. Fetch The fetch command is used to download the remote branches to our local. Syntax: git fetch # Will fetch the current remote ref
git fetch origin # Will fetch branches from origin
git fetch --all # Will fetch from all remote refs 15. Merge The merge command is used to merge two or more branch histories. For example, if we are in a branch, and we need to sync the history of branch, then we will execute the merge command in the dev-branch referring to the master. dev-branch master Syntax: git merge <target branch> Example: # In the dev-branch
git merge master The above are a few important commands that we use in our everyday work. I'd recommend referring to this doc for the . complete list of git commands Hope this article is helpful for you. Looking forward to your suggestions and feedback. Thank you! Also published . here

Master Git With 15 Essential Commands Every Developer Should Know

Introduction With the introduction of , Choreo offers the flexibility to host services written in various languages, enabling development teams to leverage the benefits of Choreo while working on polyglot applications. Buildpacks With these recent updates, deploying applications written in Node, Java, Go, or Ruby on Choreo has become effortless. In this post, I will guide you through the steps of deploying a Spring Boot application on Choreo. Before we begin, please make sure that you have the following prerequisites in place. Prerequisites An active Choreo account. Make sure you have not exceeded your free component limit. if you don’t have one already. Create a new account here Java 17 or higher. Our Spring Boot Application For this guide, I’ve chosen a popular Spring Boot example: employee service. This service facilitates the management of employee details. You can access the code for this application . Feel free to fork the repository and change it. here Our Spring Boot application provides a simple REST API with the following four operations; @RestController
@RequestMapping("/api")
public class EmployeeController {
    @Autowired
    private EmployeeService employeeService;

    @ResponseStatus(HttpStatus.OK)
    @GetMapping("/employees")
    public List<Employee> getEmployees() {
        return employeeService.getEmployees();
    }

    @ResponseStatus(HttpStatus.CREATED)
    @PostMapping("/employees")
    public Employee createEmployee(@RequestBody EmployeeRequest employee) {
        return employeeService.createEmployee(employee);
    }

    @ResponseStatus(HttpStatus.OK)
    @PutMapping("/employees/{employeeId}")
    public Employee updatedEmployee(@RequestBody EmployeeRequest employee, @PathVariable int employeeId) {
        return employeeService.updateEmployee(employeeId, employee);
    }

    @ResponseStatus(HttpStatus.NO_CONTENT)
    @DeleteMapping("/employees/{employeeId}")
    public void deleteEmployee(@PathVariable int employeeId) {
        employeeService.deleteEmployee(employeeId);
    }
} Since I’m using JPA for data persistence, I have enabled an in-memory H2 database. To test the application locally, clone the repository, and run the application using the following commands: git clone git@github.com:jaadds/employee.git

cd employee

./mvnw spring-boot:run You should see the application starting up. .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::                (v3.1.4)

2023-10-23T15:46:41.186+05:30  INFO 20491 --- [           main] c.example.employee.EmployeeApplication   : Starting EmployeeApplication using Java 19.0.2 with PID 20491 
2023-10-23T15:46:41.188+05:30  INFO 20491 --- [           main] c.example.employee.EmployeeApplication   : No active profile set, falling back to 1 default profile: "default"
2023-10-23T15:46:41.654+05:30  INFO 20491 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Bootstrapping Spring Data JPA repositories in DEFAULT mode.
2023-10-23T15:46:41.699+05:30  INFO 20491 --- [           main] .s.d.r.c.RepositoryConfigurationDelegate : Finished Spring Data repository scanning in 37 ms. Found 1 JPA repository interfaces.
2023-10-23T15:46:42.166+05:30  INFO 20491 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat initialized with port(s): 8080 (http)
2023-10-23T15:46:42.178+05:30  INFO 20491 --- [           main] o.apache.catalina.core.StandardService   : Starting service [Tomcat]
.... Let’s give it a try curl http://localhost:8080/api/employees | jq You should get the following output: [
  {
    "id": 1,
    "firstName": "Bilbo",
    "lastName": "Baggins",
    "email": "bilbo@bagend.me"
  }
] Now that we know our service is working, let’s continue with deploying it on Choreo. Preparing the Repository for Deployment Choreo needs certain details to create an endpoint for your service, such as the service port, context path, and service definition. Additionally, you need to specify the endpoint’s visibility level, choosing between public (accessible over the internet) or internal (available only to services running within Choreo). All these details should be defined in the file. endpoints.yaml For this tutorial, we will expose our employee service as a public endpoint. Create a file in your project and add the following content: .choreo/endpoints.yaml version: 0.1
endpoints:
- name: Employee API
  port: 8080
  type: REST
  networkVisibility: Public
  context: /
  schemaFilePath: openapi.yaml This is a short description of the attributes. For a detailed explanation, you can refer to the . official documentation : The name Choreo will use to create the endpoint. This name will also be used in the Developer Portal if you decide to publish a Managed API later. name : The port on which your service is running. Update this value if you have changed the port using the property. port server.port : The type of API/interface you are exposing. Valid values are , , and . type REST GraphQL gRPC : The level of visibility for the service over the network. Valid values are , , and . We'll set this to for this tutorial. networkVisibility Project Organization Public Public : The context path of your application. If you have changed the context path using the property, use that value here. Since we haven't changed it, we'll leave it as . context server.servlet.context-path / : The schema of the Service. For a REST API, this will be the OpenAPI Specification. For GraphQL and gRPC, you can specify SDL and proto files, respectively. The location is read from the repository root, not from the folder. schemaFilePath ./.choreo Since we specified a schema file path, we need to generate and place the OpenAPI Specification in the specified location. Generating the OAS While it’s possible to manually create the OpenAPI Specification (OAS) for a small API like this, Spring’s rich ecosystem provides tools to do it easily. Add the dependency to your , and start your application. springdoc-openapi pom.xml <dependency>
    <groupId>org.springdoc</groupId>
    <artifactId>springdoc-openapi-starter-webmvc-ui</artifactId>
    <version>2.1.0</version>
 </dependency> Get the OAS in YAML format using the following command: curl http://localhost:8080/v3/api-docs.yaml > openapi.yaml Commit these changes to your repository. Deploying Changes to Choreo Now that everything is set up, it’s time to deploy our Spring Boot application on Choreo. In case you missed any step, you can cross-check your work with the main branch of . In addition to the steps mentioned here, I’ve updated the dependency to avoid security scan failures. this repository snakeyaml Before deploying our Spring Boot Application on Choreo, we’ll have to create a component on Choreo. As our Application behaves as a service, we’ll be creating a type component. Service Creating a Service Component Select the “Service” Tile. Provide the following details: Field Name Value Component Name Employee Service Description Service for managing employee details Organization Your GitHub account ID Repository The repository containing your code Branch The branch with the deployable changes (in this case, it’s ) main Build Preset Java Java Project Directory Leave this as is Language Version Select the Java version from your POM (only LTS versions are available). In this case, it’s 17. 3. Click to finalize the component. Create Deploying the Service Navigate to the page. Deploy In the section, verify component details and the latest commit. Build Area Click , which will initiate a three-step wizard. Configure & Deploy First screen: Screen for adding environment variables. Skip this since we have none. Second screen: For specifying file mounts. We can skip this too. Final step: Verify details from and click . endpoints.yaml Deploy Clicking Deploy will initiate the build process. Choreo will compile the source code, build a container out of it, do a vulnerability scan, and deploy it to the development environment. Wait for the status to change to . Active Viewing Logs Once you see the Active label on the Development environment, your service should be up and running. If you want to further confirm if the service was started properly, you can check the logs. Go to the section to view logs. You’ll see logs similar to those you saw when running locally. Observability Testing the Service Finally, we can test the service. The section provides a variety of tools to do this. For our case, we will choose the Swagger Console. You may notice that the endpoint you specified in the YAML file appears in the drop-down menu. If you have defined multiple endpoints, all of them will appear in this drop-down. Test Also, observe that an API Key has been generated. This is because when exposing endpoints for consumption, Choreo automatically secures them, requiring consumers to use a proper token. You can expand on a resource and click . Execute This will give the response like this. !! You’ve successfully deployed a Spring Boot application on Choreo. Congratulations What’s Next? Learning and experimenting with the platform will help you to use Choreo better and develop production-grade applications in no time. Here are a few things you can do to familiarize yourself with the platform: Add logs to your resources, and use the Logs view in Choreo to trace requests end-to-end. This will be helpful for troubleshooting and debugging your application. Promote your Service to Production, and check whether everything runs smoothly. Experience how easily you can propagate changes across environments. Publish your service as an API in the Developer Portal. Manage, document, and share your API with other developers. Follow the to learn more about concepts like , , and . official documentation of Choreo Projects Components Environments Stay tuned for the next post, where I will talk about built-in capabilities for securing and authorizing Services on Choreo. Happy Coding!! Also published here

How to Deploy a Spring Boot Application on Choreo

How to Create a Python CLI Program for Trello Board Management (Part 2)

ট্রেলো বোর্ড পরিচালনার জন্য কীভাবে একটি পাইথন সিএলআই প্রোগ্রাম তৈরি করবেন (পর্ব 2)

So erstellen Sie ein Python-CLI-Programm für die Trello-Board-Verwaltung (Teil 2)

Cómo crear un programa CLI de Python para la gestión de tableros de Trello (Parte 2)

Comment créer un programme Python CLI pour Trello Board Management (Partie 2)

ट्रेलो बोर्ड प्रबंधन के लिए पायथन सीएलआई प्रोग्राम कैसे बनाएं (भाग 2)

Trello ボード管理用の Python CLI プログラムを作成する方法 (パート 2)

Trello 보드 관리를 위한 Python CLI 프로그램을 만드는 방법(2부)

Como criar um programa Python CLI para gerenciamento do Trello Board (Parte 2)

Как создать программу CLI на Python для управления доской Trello (часть 2)

Trello Pano Yönetimi için Python CLI Programı Nasıl Oluşturulur (Bölüm 2)

Cách tạo chương trình Python CLI để quản lý bảng Trello (Phần 2)

如何为 Trello Board 管理创建 Python CLI 程序（第 2 部分）

Mobile scanning directly to PDF can revolutionize your document workflows. Equipped with features like automatic page detection, built-in flash for better lighting, precise color management, and camera settings tailored for creating professional-grade PDFs, you can achieve remarkable results with just a few taps on your smartphone, thanks to cutting-edge technology. The following guide outlines how you can harness the power of Foxit’s Android PDF SDK to swiftly develop an app with robust scanning capabilities. Whether you’re capturing multiple photos or selecting images from your gallery, generating a PDF is as simple as a single click. This project empowers you to seamlessly integrate scanning into your existing workflows, making it a valuable addition to your mobile application. You have the freedom to incorporate your own business or application branding effortlessly, without the need to toggle elements or redesign the user interface. It provides a blank PDF viewer with a dedicated mobile scanning button, serving as a foundation for building your unique app. System Requirements Android devices’ requirements: Android 4.4 (API 19) or higher 32/64-bit ARM (armeabi-v7a/arm64-v8a) or 32/64-bit Intel x86 CPU Android Studio 3.2 or newer (supports AndroidX) The runtime environment for our demos: • Android Studio 3.2 • JDK 1.8 • Gradle Version 4.6 • Gradle Build Tool 3.2 Note: Starting with version 8.2, Foxit PDF SDK for Android will only support AndroidX, and no longer service the Android support library. Development Configuration Start up Android Studio and open the androidrdk/samples/viewer_ctrl_demo project. Add the scanning dependency library in the gradle file (view_ctrl_demo/app/build.gradle) as below: implementation(name:'FoxitPDFScan-UI', ext:'aar') 
implementation(name:'FoxitMobileScanningRDK', ext:'aar') 
implementation 'com.nostra13.universalimageloader:universal-image-loader:1.9.5' Define permission settings Before calling the Scan function, you need to obtain storage permission and permission to take pictures. If the permission to use the camera and photo album is not obtained before calling the Scan function, the app will not run correctly. Follow the steps below to set permissions. Add permission-related declarations in the AndroidManifest file using the code below: <manifest xmlns:android="http://schemas.android.com/apk/res/android"> 

     <uses-permission android:name="android.permission.VIBRATE"/> 

     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/> 

     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> 

     <uses-permission android:name="android.permission.RUN_INSTRUMENTATION"/> 

     <uses-permission android:name="android.permission.RECORD_AUDIO" /> 

     <uses-permission android:name="android.permission.CAMERA" /> Then add the following permission request code in MainActivity.java: if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) { 

    int permission = ContextCompat.checkSelfPermission(this.getApplicationContext(), Manifest.permission.WRITE_EXTERNAL_STORAGE); 

    if (permission != PackageManager.PERMISSION_GRANTED) { 

        ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);      

@Override 

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 

    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 

    if (requestCode == REQUEST_EXTERNAL_STORAGE) { 

        if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

         //Application permission is successful 

        } else { 

            UIToast.getInstance(getApplicationContext()).show(getString(R.string.fx_permission_denied)); 

            finish(); 

        } 

    } Now, let’s add the code related to the Scan function: Add a button to the UI to call the Scan function. First, write some code to add the camera button icon. You’ll define the layout, positioning and image resource for the button. This code is added to the onCreate method of the MainActivity file to make sure that the button is displayed as soon as the project loads. Make sure to add this after: protected void onCreate(Bundle savedInstanceState) { 

   (...) 

// Make sure to add this block of code after all the already existing          // view_ctrl_demo onCreate code is loaded 

    mRootView=uiExtensionsManager.getContentView(); 

    RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(RelativeLayout.LayoutParams.WRAP_CONTENT, RelativeLayout.LayoutParams.WRAP_CONTENT); 

    mIvScan = new ImageView(this); 

    mIvScan.setImageResource(R.drawable.fx_floatbutton_scan); 

    layoutParams.bottomMargin = 80; 

    layoutParams.rightMargin = 50; 

    layoutParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM); 

    layoutParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT); 

    mIvScan.setLayoutParams(layoutParams); 

    mRootView.addView(mIvScan); 

    setContentView(mRootView); 

    initScan(); 

} Now, let’s set the foundation for the app’s scanning feature. The last line of code in the onCreate method above is a call to initScan(), which is the method we’ll use to initialize the relevant classes for the project. The code below shows how you will instantiate an object from Foxit’s main PDF Scan class (PDFScanManager), then use that class to initialize the scanner and the compression features. The final method displays the scan functionality once you click the camera button. PDFScanManager pdfScanManager = PDFScanManager.instance() 

if (!PDFScanManager.isInitializeScanner()) { 

    long framework1 = 0; 

    long framework2 = 0; 

    PDFScanManager.initializeScanner(App.inst().getAppActivity().getApplication(), framework1, framework2); 

} 

if (!PDFScanManager.isInitializeCompression()) { 

    long compression1 = 0; 

    long compression2 = 0; 

    PDFScanManager.initializeCompression(App.inst().getAppActivity().getApplication(), compression1, compression2); 

} 

if (PDFScanManager.isInitializeScanner() && PDFScanManager.isInitializeCompression()) { 

    //Loaded Successfully 

        pdfScanManager.showUI(activity.this); 

} The initialization code is then added to the initScan method as follows. This method will also be added to the MainActivity class and called as soon as the project loads. This ensures your project will have all the scanning libraries and functionality available. The following imports and variables are necessary for the project: import com.foxit.pdfscan.PDFScanManager; 

  

private ImageView mIvScan; 

 private ViewGroup mRootView; 

  

private  void  initScan(){ 

        final PDFScanManager pdfScanManager = PDFScanManager.instance(); 

        mIvScan.setOnClickListener(new View.OnClickListener() { 

            @Override 

            public void onClick(View v) { 

                if (!PDFScanManager.isInitializeScanner()) { 

                    long framework1 = 0; 

                    long framework2 = 0; 

                    PDFScanManager.initializeScanner(getApplication(), framework1, framework2); 

                } 

                if (!PDFScanManager.isInitializeCompression()) { 

                    long compression1 = 0; 

                    long compression2 = 0; 

                    PDFScanManager.initializeCompression(getApplication(), compression1, compression2); 

                } 

                if (PDFScanManager.isInitializeScanner() && PDFScanManager.isInitializeCompression()) { 

  

                    pdfScanManager.showUI((Activity) mContext); 

  

                } else { 

                    UIToast.getInstance(getApplicationContext()) 

                            .show(AppResource.getString(getApplicationContext(), R.string.rv_invalid_license)); 

                } 

            } 

        }); 

    } Now that we have initialized the library and the foundation has been set, we will write two basic callback interfaces that will be used to save the document after it’s scanned: the first, ScanPDFDoneCallBack, which is entirely custom, and the second is IPDFScanManagerListener, which is available out-of-the-box in the SDK. See both below: public interface ScanPDFDoneCallBack { 

  

    /** Success, and no error occurs */ 

    int e_ErrSuccess = 0; 

    /** Failed, any unknown error occurs. */ 

    int e_ErrUnknown = 1; 

  

    /** 

     * After saving PDF successfully, return to the saving path 

     * 

     * @param errorCode if the scanned file is successfully saved as a pdf document, the errorCode is {@link #e_ErrSuccess}, otherwise is {@link #e_ErrUnknown} 

     * @param savePath the document file path. 

     */ 

    void doneCallBack(int errorCode, String savePath); 

} 

public interface IPDFScanManagerListener { 

    /** 

     * Success, and no error occurs 

     */ 

    int e_ErrSuccess = 0; 

    /** 

     * Failed, any unknown error occurs. 

     */ 

    int e_ErrUnknown = 1; 

  

    /** 

     * Called when if the scanned file is successfully saved as a pdf document. 

     * 

     * @param errorCode if the scanned file is successfully saved as a pdf document, the errorCode is {@link #e_ErrSuccess}, otherwise is {@link #e_ErrUnknown} 

     * @param path      the document file path. 

     */ 

    void onDocumentAdded(int errorCode, String path); 

} The difference between the two interfaces is if the monitoring of ScanPDFDoneCallBack is set, when you click the ‘Done’ button in the lower right corner of the figure below, it will directly save the document to the default path and exit the scanning interface, and return to the default save path through the parameter savePath. If ScanPDFDoneCallBack is not set, when you click the ‘Done’ button in the lower right corner of the figure below, an interface for selecting the save directory will pop up. The user selects the specified directory, and the document will be saved in the directory selected by the user. https://developers.foxit.com/dk_utwp/2021/10/android-mobile-scanning-tool-pdf-sdk-app.mp4 Now, you must implement the interfaces by adding them to MainActivity.java. pdfScanManager.setDoneCallBack(new ScanPDFDoneCallBack() { 

    @Override 

    public void doneCallBack(int errorCode, final String savePath) { 

        if (errorCode == e_ErrSuccess) { 

             //The document was saved successfully 

        } 

    } 

}); 

  

PDFScanManager.registerManagerListener(new IPDFScanManagerListener() { 

    @Override 

    public void onDocumentAdded(int errorCode, String path) { 

        if (errorCode == e_ErrSuccess) { 

             //The document was saved successfully 

        } 

  

    } 

}); If you want to implement further interfaces of the pdfscan class, please refer to the API Reference documents in foxitpdfsdk_8_1_android/docs. Done! The scan functionality has been successfully added to your application. Run the app, click the Scan button you’ve created previously and start your scanning experience. We work with you to add complete PDF library functionality to your project and develop across all platforms and environments on one core API. Take a 30 day free trial today by clicking here. Also published . here

How to Build Your Very Own Android Mobile PDF Scanning Tool

কিভাবে আপনার নিজস্ব অ্যান্ড্রয়েড মোবাইল পিডিএফ স্ক্যানিং টুল তৈরি করবেন

So erstellen Sie Ihr eigenes mobiles Android-PDF-Scan-Tool

Cómo crear su propia herramienta de escaneo de PDF móvil para Android

Comment créer votre propre outil de numérisation PDF mobile Android

अपना खुद का एंड्रॉइड मोबाइल पीडीएफ स्कैनिंग टूल कैसे बनाएं

独自の Android モバイル PDF スキャン ツールを構築する方法

나만의 Android 모바일 PDF 스캔 도구를 만드는 방법

Como construir sua própria ferramenta de digitalização de PDF móvel para Android

Как создать свой собственный мобильный инструмент для сканирования PDF-файлов на базе Android

Kendi Android Mobil PDF Tarama Aracınızı Nasıl Oluşturabilirsiniz?

Cách xây dựng công cụ quét PDF dành cho thiết bị di động Android của riêng bạn

如何构建您自己的 Android 移动 PDF 扫描工具

It is well known that most transactions on Ethereum require a fee to ensure that the network is spam-resistant and doesn’t get stuck in an endless loop of calculations. The gas fee is the amount of gas required to complete the transaction multiplied by the cost per unit of gas. The fee is paid whether the transaction succeeds or fails. As of November 2023, gas costs about 10 gwei. Although 1 gwei is now equivalent to about US$0.000002, we need to understand that this is just one unit, and you have to pay tens and sometimes hundreds of thousands of gas to complete transactions, which will be a more tangible amount. That is why we need to keep optimization in mind. As developers, we cannot influence the price of gas, so we need to focus on the units of gas consumed by the code to reduce it as much as possible. Due to the optimizations, developing on is different from developing Web 2.0 applications because we have to give up familiar patterns, such as splitting into small functions, for ease of testing. In this article, I will provide several examples, for each of which I will give an optimized and unoptimized smart contract with the amount of gas consumed. Ethereum Optimizations and operation codes There are two main approaches to optimization: (minimizing the size of the smart contract and the cost of Optimizing the cost of deployment executing the constructor) Optimizing each function call The first thing to check is that the smart contract does not contain unnecessary and unused code, as deployment is compiled to bytecode, and the more of it there is, the more expensive deployment will be. Here are some expensive gas operation codes in EVM: – Deploys a smart contract (32,000 gas) CREATE/CREATE2 – Stores the value in memory (20,000 gas if the slot has not been accessed, 2,900 SSTORE otherwise) (address(this).balance) – (2,600 gas if not previously accessed) BALANCE A complete list of all the codes for the different forks can be found here: . https://www.evm.codes Optimizing each function call is a better strategy because the smart contract is deployed once. Tips Do not initialize variables with default values If a variable is not initialized, the compiler assumes that it has a default value: for , for , for , for . So, initializing with default values is a waste of gas. 0 uint “” string false bool 0x(0) address Organize variables stores variables in cells of 32 bytes. If a variable is smaller than a cell, it is packed with another variable, but such variables must be declared side by side. Solidity Do not truncate variables When declaring a single variable, it makes sense to use , because otherwise, the variable has to be truncated, which takes a bit more time. uint256 Use static values In cases where there is an option to pre-calculate static values, it is better to use it, even if it is hardcoded. For instance, in the example below, you need to call two functions that increase the gas consumption. Use constant variables For variables that will be constants, just one keyword will save a lot of gas. immutable Do not declare temporary variables It may seem harmless to introduce an extra variable that is stored in memory rather than on the , but adding an intermediate variable requires more gas. blockchain Use mappings instead of arrays This is not always possible, but where possible, arrays should be avoided as they are more expensive to work with. Prefer a fixed-length array to a dynamic one In some cases, you cannot avoid using arrays. Dynamic arrays are more expensive than fixed-length arrays because you have to change the array length when using the push and pop functions. Use the data type you need in the array What applies to variables does not apply to arrays. If you specify the required type, the engine will pack the data in the correct way. Do not create many functions that call each other In any other language, the smaller the function, the better it is for debugging and testing, but things are not the same in Solidity. It is also desirable to minimize function calls to third-party smart contracts. Avoid multiple changes to state variables If there is a variable in the blockchain whose value needs to be changed multiple times, it is better to create a temporary variable and write the final value to the blockchain after the loop is executed. Optimize gas by removing unnecessary variables Ethereum offers gas refunds for deleting variables. Using the keyword with a variable name will return 15,000 gas but no more than half of the transaction value. delete Use selfdestruct() to compensate for gas Deleting a contract without the option to restore will return 24,000 gas but no more than half of the transaction value. Use Solidity Gas Optimizer The built-in optimizer allows you to adjust the value of iterations depending on your optimization goals. A lower value should be set to minimize deployment costs, and a higher value should be set to optimize runtime costs. Below is the configuration file for the Solidity Optimizer with Hardhat. Summary At compile time, contract code is converted to byte code for EVM, and transaction codes have a cost depending on the Ethereum fork. Despite initiatives to reduce the cost of gas (in particular, the introduction of variable size blocks in the London update, which changed the way fees are calculated), as developers, we need to optimize both the deployment and function calls in smart contracts to save money on deployment and execution.

Smart Contract Optimization: How to Use Less Gas in Ethereum

Step-by-Step Installation

How to Mint Solana NFTs Using Anchor and Metaplex

is a very popular concept you can hear about from many different sources. It seems to be a completely new technology, but it can already be applied in many areas of life. Now we will learn what blockchain is and how it differs from traditional networks and databases. Blockchain Typically, individuals rely on traditional banks or payment systems for currency exchange. These are centralized systems where information is stored and processed on dedicated servers. However, the use of centralized networks, which are managed and maintained by a single entity, limits control over one's funds and data. These systems often require identity verification and do not offer transparent, publicly accessible transactions, making them incompatible with your style of exchange. The blockchain network allows you to manage your funds all by yourself and make fast and cheap transfers from anywhere in the world where there is an Internet connection. Blockchain is decentralized since it is not under the control of a small group of people. Also, unlike traditional centralized services and payment systems, the blockchain network has no restrictions on the user’s location, age, or nationality. The data is processed with the collaboration of thousands of computers worldwide. Blockchain as a data structure In a traditional , information is stored in an independent order. It can be freely edited and deleted without damaging the integrity of other data. In the blockchain, the data is in blocks. The blocks are securely connected in a strict chain. The chain can be represented as a book, where new pages, in our case, blocks, are constantly added. All pages are numbered, bound together, and go in strict order, one after the other. database The data chain has two properties that ensure its reliability: It is impossible to take an already included block and rewrite it. Entries can only be made to a new block. Other community members check new entries. Therefore, scammers cannot write what they want into the book. Next, let’s look at how these features are implemented inside the blockchain. Blockchain Properties Property #1. What is recorded in the blockchain cannot be overwritten For the chain to be complete, each subsequent block must be connected to the previous one. This connection between blocks is similar to the connection between commits in GitHub. To understand this comparison, let’s look at how commits work. When we commit, GitHub gathers data about all the file states in the repository. From this data, it calculates the unique identifier of the commit. In this case, the commit ID is obtained not from the state of all files but from the changes that occurred from the previous commit. Thus, the hash is obtained from the following data: links to the previous commit. a list of changes that have taken place Thanks to this, the commits are tightly connected: the identifier of the new commit is obtained from the data containing the identifier of the previous one. This way, we can easily check the integrity of the data. To do this, you need to get a new identifier for the current commit and compare it with the original one. If the data has not changed, we will always get the same result. Hash: a link to the block The data in the blocks are linked by their hash identifier. A special data modification algorithm, the hashing function, is responsible for its creation. Hashing is a function that converts a string of data of any length into a string of data of a certain length. That is, any input data is changed according to a certain algorithm. As a result, we get a unique fixed-length data string. For example, each commit has a different number of modified lines of code, but the hash length of each commit is the same. If we hash one string and get a hash, then change just any one character in the original string and hash it again, we will get a completely different hash. This is called the “avalanche effect” of the hash. In this case, the same string will always give the same result. For example, we applied a hash function to the string “example” and got a hash. If we apply the function to the string “eXample”, we will get a completely different hash, but of the same length. hashing There is no algorithm that can perform the reverse hashing operation. Therefore, the hashing function is a one-way function. But you can find the source data from the hash. To do this, hash all possible variants of the source data until the result is the right hash. However, doing this requires a huge amount of computing power and time and is considered unfeasible. It is generally assumed that the hash is unique for almost every data set. In reality, several different datasets can have the same hash. But this is unlikely due to the huge number of hash options. If we change one block in the blockchain, we will immediately change all the blocks that follow the changed one. That is, we will get a new chain, which will be discarded by community members. This mechanism allows you to quickly and unambiguously verify the integrity and reliability of any link in the chain or even the entire chain. To do this, calculate the hashes of all blocks in the plot and compare the results with the hashes in the corresponding blocks. A chain of blocks that are strictly interconnected. Each block stores a certain number of records and the result of hashing the entire previous block. Each record that updates data in the blockchain is called a transaction. If you replace at least one symbol in a block, the hash of this block and all subsequent blocks will change. This guarantees the integrity of the chain. Here’s an example. Let’s take a few blocks already included in the chain and try to add a transaction to the block that was previously not in it. Since the block body has changed, therefore its hash has also changed. As a result, all hashes of subsequent blocks will change. Thanks to hashing, each transaction and each block are closely related to each other. If you try to change any data, all the hashes of subsequent blocks will completely change. The blockchain is decentralized, and you must provide your new changeable block to all community members. Each member will independently check your block and might disagree with the changes you have included. But we’ll talk about how it works further. Property #2. It is impossible to record false data False data cannot be written to the blockchain because new blocks and data are checked for authenticity. Let’s analyze how it works. Each participant has a copy of the chain and tools for verifying the validity, such as asymmetric and proof of work. Later we will look at what it is and how it works. When one of the participants wants to add a new block, the other participants check that the data of this block does not contradict the data from their copy and that all transfers from addresses were initialized by their owners. They make sure that the data in this new block is not falsified and can be added to the blockchain. At the same time, participants do not trust one data source separately. For a block to get into the blockchain, its authenticity must be confirmed by most participants. It is important to remember that only those blocks verified for authenticity and approved by most network participants get into the blockchain. cryptography Native currency and community members Like any database or information system, blockchain must ensure viability and security. Someone has to keep the entire history of transfers, check transactions, and add new blocks. You need a computer or server with special software to perform these tasks. It exchanges information with many of the same devices and forms a network. For example, a computer can become a network node that communicates with all other devices on the network. It can synchronize with the entire network and store the full history of the blockchain, starting from the first block. Such a computer is called a full node. Full — because it stores the entire history of transactions and blocks. There are different nodes with different functions. For example, storing the entire blockchain, adding new blocks, and verifying transactions. But to use the blockchain, installing a node at home is not necessary. For this purpose, a user node that performs minimal load is suitable. It is enough to work with personal transactions and addresses. It is called the light client and is usually presented as a wallet of digital assets. It is not entirely clear what the motivation of users is to install special software and spend resources and time to run a node. Besides enthusiasm… You can only have a light client, which does not require anything. But if you are an enthusiast, then… The blockchain has a mechanism for encouraging community members who ensure the operability and security of the blockchain network. For the blockchain to be decentralized, anyone has the opportunity to install a node and become a participant in the life of the network. To implement this, the source code contains a special mechanism for rewarding those who support the efficiency and security of the blockchain. Blockchains and their general characteristics There are a lot of blockchain networks. Among the most popular are Bitcoin, Ethereum, Binance Smart Chain, Solana, Cosmos, Polkadot, and Avalanche. They all differ in many ways but also have some common properties. First, let’s look at what all blockchains have in common: — if you have made a transfer or other action in the blockchain, it is impossible to simply cancel it. Irreversible transactions — users can view any block or transaction initialized in the public blockchain. Transparency — blockchain is a structure in which changes occur only with the consent of the majority of community members. No one can make decisions about anything alone. Decentralization — there are no conditions to become a community member or developer. Anyone can access the technology. Open access — each participant has a copy of the blockchain. They can exchange new data with other users, and only after verification by the majority will they be valid. Distribution — any data stored in the blockchain can be verified for authenticity. That is, you can easily find out if something has been changed. Verifiability These are the main blockchain properties, but not the only ones. There are many use cases for blockchain technology, and it is essential to look at the differences between networks in detail. In the next article, I will go into more detail about the differences between the different blockchains

Revisiting Blockchain Basics: Part 1—What is a Blockchain? 

How to Dockerize And Deploy Django Applications 

জ্যাঙ্গো অ্যাপ্লিকেশনগুলি কীভাবে ডকারাইজ এবং স্থাপন করবেন

So dockerisieren und stellen Sie Django-Anwendungen bereit

Cómo Dockerizar e implementar aplicaciones Django

Comment Dockeriser et déployer des applications Django

Django एप्लिकेशन को डॉकराइज़ और तैनात कैसे करें

Django アプリケーションを Docker 化してデプロイする方法

Django 애플리케이션을 Docker화하고 배포하는 방법

Como Dockerizar e implantar aplicativos Django

Как Dockerize и развертывать приложения Django

Django Uygulamalarını Dockerize Etme ve Dağıtma

Cách Dockerize và triển khai các ứng dụng Django

如何 Docker 化和部署 Django 应用程序

In the world of front-end development, Vue.js has gained immense popularity for its simplicity and flexibility. One of the key features that makes Vue.js so powerful is its lifecycle hooks. These hooks allow developers to execute code at specific stages in a Vue component's lifecycle, making it possible to manage and manipulate data efficiently. In this article, we'll dive deep into Vue.js lifecycle hooks, exploring what they are, how they work, and providing practical examples to help you grasp their usage effectively. Introduction to Vue.js Lifecycle Hooks Before we delve into the details, let's start with the basics. Vue.js lifecycle hooks are special methods provided by Vue that allow you to perform actions at various stages of a component's existence. These stages include: : This is the initialization phase of a Vue component. It involves setting up data, initializing events, and preparing the component for rendering. Creation : During this phase, the component is inserted into the DOM (Document Object Model), making it visible to the user. It includes the and hooks. Mounting beforeMount mounted : When data changes and the component needs to re-render, the updating phase is triggered. This phase includes the and hooks. Updating beforeUpdate updated : When a component is removed from the DOM, it goes through the destroying phase. This phase includes the and hooks. Destroying beforeDestroy destroyed : If an error occurs during the component's lifecycle, the error handling phase includes the hook. Error Handling errorCaptured Now, let's explore each of these phases and their respective hooks with practical examples. Creation Phase Hook beforeCreate The hook is called right before a Vue instance is initialized. At this stage, data and events have not been set up yet. It's an ideal place for actions that require low-level setup. beforeCreate <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  beforeCreate() {
    console.log('Before Create Hook: Component is about to be initialized.');
  },
  data() {
    return {
      message: 'Hello, Vue!'
    };
  }
};
</script> Hook created The hook is called after the Vue instance is initialized. At this point, data is available, and you can perform additional setup, such as making API requests. created <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: ''
    };
  },
  created() {
    // Simulate an API request
    setTimeout(() => {
      this.message = 'Data fetched from an API';
    }, 2000);
  }
};
</script> Mounting Phase Hook beforeMount The hook is called right before the component is rendered. It's useful for performing actions before the DOM is updated. beforeMount <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  beforeMount() {
    console.log('Before Mount Hook: Component is about to be rendered.');
  }
};
</script> Hook mounted The hook is called after the component is rendered and inserted into the DOM. It's commonly used for tasks like fetching external data or setting up event listeners. mounted <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: ''
    };
  },
  mounted() {
    // Simulate an API request
    setTimeout(() => {
      this.message = 'Data fetched from an API';
    }, 2000);
  }
};
</script> Updating Phase Hook beforeUpdate The hook is called when data changes, right before the component re-renders. It's useful for performing actions before the DOM updates. beforeUpdate <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  methods: {
    updateMessage() {
      this.message = 'Updated message';
    }
  },
  beforeUpdate() {
    console.log('Before Update Hook: Data is about to change.');
  }
};
</script> Hook updated The hook is called after the component re-renders due to data changes. It's useful for performing tasks after the DOM has been updated. updated <template>
  <div>
    {{ message }}
    <button @click="updateMessage">Update Message</button>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  methods: {
    updateMessage() {
      this.message = 'Updated message';
    }
  },
  updated() {
    console.log('Updated Hook: Data has changed, and the component is updated.');
  }
};
</script> Destroying Phase Hook beforeDestroy The hook is called right before a component is destroyed. It's useful for performing cleanup tasks such as removing event listeners or clearing timeouts. beforeDestroy <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  methods: {
    destroyComponent() {
      // Perform cleanup tasks here
      console.log('Component is about to be destroyed.');
    }
  },
  beforeDestroy() {
    this.destroyComponent();
  }
};
</script> Hook destroyed The hook is called after a component is destroyed. This is the last hook in the component's lifecycle. destroyed <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  methods: {
    destroyComponent() {
      // Perform cleanup tasks here
      console.log('Component is destroyed.');
    }
  },
  beforeDestroy() {
    this.destroyComponent();
  },
  destroyed() {
    console.log('Destroyed Hook: Component is destroyed.');
  }
};
</script> Error Handling Phase Hook errorCaptured The hook is used for global error handling within a component and its children. It allows you to catch and handle errors that occur during rendering, in lifecycle hooks, or in child components. errorCaptured <template>
  <div>
    {{ message }}
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello, Vue!'
    };
  },
  errorCaptured(err, vm, info) {
    // Handle errors here
    console.error('Error Captured Hook:', err, vm, info);
  }
};
</script> Conclusion Vue.js lifecycle hooks are essential for managing the behavior of Vue components throughout their lifecycle. By understanding when and how to use these hooks, you can create dynamic and responsive web applications with ease. Remember to choose the appropriate hook for your specific needs, whether it's setting up data, handling updates, or performing cleanup tasks. Mastering Vue.js lifecycle hooks is a crucial step toward becoming a proficient Vue.js developer.

Mastering Vue.js Lifecycle Hooks: A Comprehensive Guide with Examples

Table of contents Prerequisites Scope of this tutorial Installation of Dependencies Why use code generation tools? Freezed Code Generator Riverpod Code Generator Notifier Provider AsyncNotifierProvider Recap Conclusion References Maximizing the performance of your app is crucial for delivering a seamless user experience. As software developers, we constantly seek out tools that can enhance our coding experience while improving the efficiency and quality of our code. This beginner's guide focuses on utilizing the power of AsyncNotifierProvider and NotifierProvider from Riverpod, together with the Riverpod code generator, for efficient state management. By incorporating these tools, you can generate providers faster, simplify the process of passing ref property around, and streamline debugging. The guide includes simple examples that demonstrate how to use these providers in your project and leverage the benefits of the Freezed and Riverpod code generators. Flutter Prerequisites Basic knowledge of dart A basic understanding of flutter and state management. A code editor (Android Studio or recommended) VScode A mobile device or emulator to build on. You’ve read the first article in this series or have at least a basic knowledge of how Riverpod works 👇🏽 https://clouds.hashnode.dev/the-ultimate-guide-to-mastering-riverpod-for-flutter-beginners Scope of this tutorial In this tutorial, we will cover the following: Examples to show the implementation of the Notifier and AsyncNotifier Providers. How to use code generation tools like Freezed and Riverpod code generator. How to use to handle loading state AsyncValue How to use when working with an immutable class. copyWith Installation of Dependencies First, you will need to get to your and add the following packages pubspec.yaml dependencies:
  flutter_riverpod: ^2.1.3
  riverpod_annotation: ^1.1.1
  freezed_annotation: ^2.2.0
  freezed: ^2.3.2

dev_dependencies:
  build_runner:
  riverpod_generator: ^1.1.1 Then run flutter pub get You have successfully added the necessary dependencies to your project. Why use code generation tools? If you choose to work without code generation tools, your Riverpod providers will still be fully functional. However, Riverpod greatly recommends using code generation tools. Code generation is using a tool to generate code. In dart, once you add the code generation syntax and compile, your code is automatically generated. Doing this saves you the time and energy you would have used to write that code, especially when you are working on a big project and need to handle those tasks repeatedly. Code generation will help prevent those errors that can happen when doing the same task repeatedly. It makes debugging better and generally makes your life easier. Freezed Code Generator Freezed is a code generation package that helps you create data classes with Dart. With the use of Freezed you can generate models, unions and much more. Freezed allows you to focus on the definition of your data class, instead of writing long lines of code that may be error-prone. Riverpod Code Generator With the Riverpod code generation package, it is now easier to declare providers. You no longer need to write your providers by hand or wonder which particular provider will suit your use case. All you need to do is follow the syntax for defining your Riverpod code generator and annotate your code, then with you can generate all your providers. build_runner For instance, this is the code generation syntax for these different Riverpod providers For Providers: @riverpod
int foo(FooRef ref) => 0; For FutureProviders: @riverpod
Future<int> foo(FooRef ref) async {
  return 0;
} For StateProviders: @riverpod
class Foo extends _$Foo {
  @override
  int build() => 0;
} You can notice that there is a pattern for creating the providers. Once you put the correct syntax you can generate the providers just like that. Notifier Provider Riverpod 2.0 came with the addition of two new provider types, the NotifierProvider, and the AsyncNotifierProvider. Riverpod recommends you use the NotifierProvider instead of the ChangeNotifier and StateNotifier providers, so we are focusing on these two. The NotifierProvider is used to listen to and expose a Notifier. A Notifier exposes a state that can change over time. Let’s consider a simple example 👇🏽 We will build a random string generator with two buttons, one to generate a new string and the other to clear the entire list of strings. In this example, we will also be using the Riverpod code generator. First, using Riverpod annotation and the code syntax below, we will create a NotifierProvider. We will also add the functions for adding a random string and clearing the list of strings. We will add the name of the file to be generated by specifying with as seen in the code. part Note: The name of the file to be generated is the same as the name of the current file you are working on. When specifying it with you will need to add as that is how Riverpod-generated files are named. part .g.dart import 'package:riverpod_annotation/riverpod_annotation.dart';

part 'notifier_list_provider.g.dart';

@riverpod
class RandomStrNotifier extends _$RandomStrNotifier{
  @override
  List<String> build() {
    return [];
  }
//using Dart's spread operator we create a new copy of the list
  void addString(String randomStr){
    state = [...state, randomStr];
  }

  void removeStrings(){
    state = [];
  }
} From our code, we can see that the returns an empty List, then we added the two functions to add to the list and clear the list. NotifierProvider and AsyncNotifierProvider support immutable state, because our state is immutable, we can not say or . So we create a new copy of the list. is used for updating the UI state. RandomStrNotifier state.add state.remove state To run the code generator, run this command on the terminal: flutter pub run build_runner watch --delete-conflicting-outputs After it has successfully run, you can see your generated provider file, in your project tab, in your code editor. From the image above you can see what the generated file will look like. Note: If you get the error then run the command on your terminal. Could not find a file named "pubspec.yaml" in "C:\Users\… dart pub get Moving on, let’s add this provider and the functions to our UI Widget build(BuildContext context, ref) {
        // rebuid the widget when there is a change
    List<String> randomStrList = ref.watch(randomStrNotifierProvider);
    final random = Random();
    return Scaffold(
      appBar: AppBar(
        title: const Text("RiverPod Notifier Example App"),
        backgroundColor: Colors.brown,
      ),
      body: SingleChildScrollView(
        child: Column(
          children: [
            Column(
              children: [
                                //map to a list
                ...randomStrList.map((string) =>
                    Container(
                      alignment: Alignment.center,
                      margin: const EdgeInsets.only(bottom: 10,top: 5),
                      height: 30,
                        width: 300,
                        color: Colors.brown,
                        child: Text(string.toString(),
                          style: const TextStyle(
                            color: Colors.white
                          ),
                        )))
              ],
            ),
            Row(
              mainAxisAlignment: MainAxisAlignment.spaceAround,
              children: [
                ElevatedButton.icon(
                  icon: const Icon(Icons.add),
                  label: const Text('Generate'),
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Colors.brown, // Background color
                  ),
                  onPressed: () {
                                    //add string to list function
                    ref.read(randomStrNotifierProvider.notifier).addString("This is the "
                        "random String ${5  + random.nextInt( 1000 + 1 - 5)}");
                  },
                ),

                ElevatedButton.icon(
                  icon: const Icon(Icons.clear),
                  label: const Text('Clear'),
                  style: ElevatedButton.styleFrom(
                    backgroundColor: Colors.brown, // Background color
                  ),
                  onPressed: () {
                                    //clear list function
                    ref.read(randomStrNotifierProvider.notifier).removeString();
                  },
                )
              ],
            )
          ],
        ),
      ),
    ); As you can see the Riverpod code generator, generated a matching randomStrNotifierProvider When you run the app it should look like this 👇🏽 AsyncNotifierProvider The AsyncNotifierProvider is used to listen to and expose an asyncNotifier. The AsyncNotifier is a notifier that is asynchronously initialized. Let’s dive into the example: We will be building a simple app that loads a list of products after a time duration of 3 seconds with a button to clear the list of products. First, we will use the Freezed code generator tool to create our product class. Then using the method we will create the product objects that will be going into our list. We will add the name of the file to be generated by specifying with as seen in the code. The name of the generated file is the current name of your file and This is how the freezed files are named. copyWith part .freezed.dart import 'package:freezed_annotation/freezed_annotation.dart';
//replace with part 'name_of_your_file.freezed.dart';
part 'async_notifier_list_provider.freezed.dart';

@freezed
class Product with _$Product{
  const Product._();
  const factory Product({
    String? name,
    String? description,

  }) = _Product;

}

  const Product _product1 =  Product(name: "Dart course for beginners",
                            description: "This is course will make you a dart star");
  final Product _product2 = _product1.copyWith(description: "This course will make you a pro");
  final Product _product3 = _product1.copyWith(name: "Ultimate Dart course for beginners");

final products = [
              _product1,
              _product2,
              _product3,
]; We can run this command on the terminal to generate the freezed file flutter pub run build_runner watch --delete-conflicting-outputs The image above shows how the Freezed generated file will look like. We used the method to create new objects of product that we added to the list. The method is used for returning a new object with the same properties as the original but with the values you have specified, it is used when working with immutable structures like Freezed. copyWith copyWith Now we will go ahead and add our Riverpod provider class, which will be fetching the list of products after 3 seconds. We will also add the function to clear the list of products as well. //replace with part 'name_of_your_file.g.dart';
part 'async_notifier_list_provider.g.dart';

@riverpod
class AsyncProducts extends _$AsyncProducts {
  Future<List<Product>> _fetchProducts() async {
    await Future.delayed(const Duration(seconds: 3));
    return products;
  }

  @override
  FutureOr<List<Product>> build() async {
    return _fetchProducts();
  }

  Future<void>clearProducts()async {
    state = const AsyncValue.loading();
    state = await AsyncValue.guard(() async{
      await Future.delayed(const Duration(seconds: 3));
      return [];
    });
  }

} The asyncNotifierProvider returns a future list of products. To modify the UI we will now create the function, using we can easily manage the loading, error state, and data state. clearProducts AsyncValue class Looking at the class, is used to transform a Future that can fail into something safe to read, it is recommended to use this instead of try and catch blocks. it will handle both the data and error states. AsyncValue AsyncValue.guard Next, run this command on the terminal to generate the necessary Freezed and Riverpod code flutter pub run build_runner watch --delete-conflicting-outputs Let’s add this provider and function to our UI Widget build(BuildContext context, WidgetRef ref) {
    final productProvider = ref.watch(asyncProductsProvider);
    return Scaffold(
        appBar: AppBar(
            title: const Text("AsyncNotifier"),
            actions: [
              IconButton(
                icon: const Icon(
                  Icons.clear,
                  color: Colors.white,
                ),
                onPressed: () {
                  ref.read(asyncProductsProvider.notifier).clearProducts();
                },
              )
            ]
        ),

      body: Container(
        child: productProvider.when(
          data: (products)=> ListView.builder(
              itemCount: products.length,
              itemBuilder: (context, index){
                return Padding(
                  padding: const EdgeInsets.only(left: 10,right: 10,top: 10),
                  child: Card(
                    color: Colors.blueAccent,
                    elevation: 3,
                    child: ListTile(
                      title: Text("${products[index].name}",style: const TextStyle(
                          color: Colors.white,  fontSize: 15)),
                      subtitle: Text("${products[index].description}",style: const TextStyle(
                          color: Colors.white,  fontSize: 15)),
                    ),
                  ),
                );
              }),
          error: (err, stack) => Text("Error: $err",style: const TextStyle(
              color: Colors.white,  fontSize: 15)),
          loading: ()=> const Center(child: CircularProgressIndicator(color: Colors.blue,)),
        ),
      ),
    );
  } Here we can see that by calling we can access our provider, then we add the clear product function to the by calling . Now we can handle the different states of the response, using ref.watch onPressed ref.read productProvider.when When you run the app it should look like this 👇🏽 Recap We have come to the end of this tutorial. Here we have learned that: The NotifierProvider listens to and exposes a notifier, when there is a change in state, it automatically updates the UI. AsyncNotifierProvider is used to listen and expose a notifier that is asynchronously initialized. Using code generation tools like Freezed and Riverpod code generators, we can easily generate data and provider classes with very little code. The copyWith method used to create a new object but with values you specified, when working with immutable classes. Finally, the AsyncValue class is used to efficiently handle data, loading, and error states. Conclusion Congratulations, you have successfully learned how to use Riverpod’s newest providers, NotifierProvider and AsyncNotifierProvider to manage state, how to use code generation tools to generate code, and how to use copyWith method and AsyncValue class. If you enjoyed this article, do well to leave a reaction and follow me for more content. If you have any questions or spot any errors, please do leave feedback. References Riverpod Docs Also published here.

Optimizing Flutter Performance: A Guide to (Async)NotifierProvider, Freezed, and Riverpod Code Gen

It turns out that well-known algorithms like , , , and are essentially variations of the same algorithm. BFS DFS Dijkstra A-Star In other words, it is possible to implement a universal data structure that can switch between these algorithms without requiring changes to its core components. While there are some limitations to consider, exploring this approach is interesting. You can find all the working for these algorithms on my GitHub repository . I recommend experimenting with the code while reading this article since practical experience enhances learning more than just theoretical understanding. code here Graph representation Let's consider a graph with 25 nodes arranged in a 5x5 grid, where we aim to find a path from Node 0 in the top left corner to Node 24 in the bottom right corner: ( 0  ) - ( 1  ) - ( 2  ) - ( 3  ) - ( 4  )
  |        |        |        |        |
( 5  ) - ( 6  ) - ( 7  ) - ( 8  ) - ( 9  )
  |        |        |        |        |
( 10 ) - ( 11 ) - ( 12 ) - ( 13 ) - ( 14 )
  |        |        |        |        |
( 15 ) - ( 16 ) - ( 17 ) - ( 18 ) - ( 19 )
  |        |        |        |        |
( 20 ) - ( 21 ) - ( 22 ) - ( 23 ) - ( 24 ) Each of the mentioned algorithms is capable of achieving this, but they have their own limitations: Both BFS and DFS algorithms operate on unweighted graphs, disregarding edge weights. Although they can find any path, they do not guarantee the optimal path. Both Dijkstra's and A-Star algorithms work on weighted graphs but should not be used with graphs containing negative weights. A-Star is usually faster due to its optimization, which incorporates Euclidean coordinates during pathfinding. In this article, I do not cover the basic concepts, hoping that you are already familiar with them. If the terminology mentioned above seems daunting to you, you should probably learn the basics as well. However, playing around with these code examples can still be exciting. To account for these limitations, let's assign imaginary coordinates to each node (X, Y): (0, 0) - (0, 1) - (0, 2) - (0, 3) - (0, 4)
   |        |        |        |       |
(1, 0) - (1, 1) - (1, 2) - (1, 3) - (1, 4)
   |        |        |        |       |
(2, 0) - (2, 1) - (2, 2) - (2, 3) - (2, 4)
   |        |        |        |       |
(3, 0) - (3, 1) - (3, 2) - (3, 3) - (3, 4)
   |        |        |        |       |
(4, 0) - (4, 1) - (4, 2) - (4, 3) - (4, 4) Finally, let’s assign some weight to every edge in the graph: (0, 0) -1- (0, 1) -1- (0, 2) -1- (0, 3) -2- (0, 4)
   |          |          |          |         |
   2          1          1          2         2
   |          |          |          |         |
(1, 0) -2- (1, 1) -1- (1, 2) -2- (1, 3) -1- (1, 4)
   |          |          |          |         |
   2          1          1          1         1
   |          |          |          |         |
(2, 0) -1- (2, 1) -1- (2, 2) -1- (2, 3) -2- (2, 4)
   |          |          |          |         |
   2          1          1          1         2
   |          |          |          |         |
(3, 0) -2- (3, 1) -2- (3, 2) -1- (3, 3) -2- (3, 4)
   |          |          |          |         |
   2          1          1          2         2
   |          |          |          |         |
(4, 0) -2- (4, 1) -1- (4, 2) -2- (4, 3) -2- (4, 4) In C++, this structure may be represented as follows: class GraphNode
{
public:
    int X;
    int Y;
};

class Graph
{
public:
    vector<vector<pair<int, int>>> Edges;
    vector<GraphNode> Nodes;
}; The edges list in the Graph is represented by an array of arrays, where the index corresponds to the number of the exit nodes for each edge in the graph. Then, every element contains a pair of values: The number of the entering nodes for each edge in the graph. The weight of the edge. Using this simple construct, we can traverse every node in the graph and obtain all the necessary information about its connections: int toNode = graph.Edges[fromNode][neighbourIndex].first;
int weight = graph.Edges[fromNode][neighbourIndex].second; Now, let's create some custom connections within the graph to observe the effect on how our universal algorithm works. Since this code is not the main focus here, I will provide links to the relevant methods: Generating a list of nodes Creating custom connections Alternatively, it is also possible to in this graph with even less code. However, this approach might not provide a comprehensive understanding of the actual differences in how the algorithms traverse the graph. lazily generate all the connections and weights Universal algorithm At the core of the universal path-finding algorithm lies the universal data structure, which we will refer to as the "Queue" for the purposes of this project. However, it is not a classic FIFO (First-In-First-Out) data structure. Instead, it is a general structure that allows us to implement node queuing during traversal while being able to change the queuing mechanism based on the algorithm being used. The interface for this "Queue" is simple: class pathFindingBase
{
public:
  virtual void insert(int node) = 0;
  virtual int getFirst() = 0;
  virtual bool isEmpty() = 0;
}; Before we delve into the details of the Queue, let's examine the traversal algorithm itself. Essentially, it closely resembles a typical A-Star or Dijkstra algorithm. First, we need to initialize a set of collections that enable us to: Maintain a list of nodes that have not been processed yet (colored white), are currently being processed (colored gray), and have been processed/visited (colored black). Keep track of the current distance of the shortest path from the start node to each node in the collection. Store a list of pairs of previous-next nodes that allows us to reconstruct the final path afterward. main.cpp#L18 const int INF = 1000000;
const int WHITE = 0;
const int GREY = 1;
const int BLACK = 2;

/// <summary>
/// Universal algorithm to apply Path search using BFS, DFS, Dijkstra, A-Star.
/// </summary>
vector<int> FindPath(Graph& graph, int start, int finish, int finishX, int finishY)
{
  int verticesNumber = graph.Nodes.size();

  vector<int> nodeColor(verticesNumber, WHITE); // All the nodes are White colored initially
  vector<int> shortestPath(verticesNumber, INF); // Current shortest path found from Start to i is some large/INFinite number from the beginning.
  vector<int> previousVertex(verticesNumber, -1); // Index of the vertex/node that is predecessor of i-th vertex in a shortest path to it.

  // We should use pointers here because we want to pass the pointer to a data-structure
  // so it may receive all the updates automatically on every step.
  shared_ptr<vector<int>> ptrShortestPath = make_shared<vector<int>>(shortestPath);
  shared_ptr<Graph> ptrGraph = make_shared<Graph>(graph); Next, we need to initialize our data structure. By using the code provided in the , you can simply uncomment the necessary line of code. The code is not designed to select the data structure based on a parameter because I want you to actively experiment with it to gain a better understanding (yes, I'm a tough guy :D). GitHub repository //////////////////////////////////////////////////
  // TODO
  // UNCOMMENT DATA STRUCTURE YOU WANT TO USE:

  //dfsStack customQueue;
  //bfsQueue customQueue;
  //dijkstraQueue customQueue(ptrShortestPath);
  //aStarQueue customQueue(finishX, finishY, ptrGraph, ptrShortestPath);

  // END OF TODO
  ///////////////////////////////////////////////// Finally, the algorithm itself. Essentially, it is a combination of all three algorithms with some additional checks. We initialize a "customQueue" and execute the algorithm until it becomes empty. When examining each neighboring node in the graph, we enqueue every node that potentially needs to be traversed next. Then, we call the getFirst() method, which extracts only one node that should be traversed next in the algorithm. main.cpp#L48 customQueue.insert(start);
  nodeColor[start] = BLACK;
  ptrShortestPath->at(start) = 0;

  while (!customQueue.isEmpty()) // Traverse nodes starting from start node.
  {
    int current = customQueue.getFirst();

    if (current == finish) // If we found finish node, then let's print full path.
    {
      vector<int> path;

      int cur = finish;
      path.push_back(cur);

      while (previousVertex[cur] != -1) // Recover path node by node.
      {
        cur = previousVertex[cur];
        path.push_back(cur);
      }

      reverse(path.begin(), path.end()); // Since we are at the finish node, reverse list to be at start.

      return path;
    }

    for (int neighbourIndex = 0; neighbourIndex < graph.Edges[current].size(); neighbourIndex++)
    {
      int to = graph.Edges[current][neighbourIndex].first;
      int weight = graph.Edges[current][neighbourIndex].second;

      if (nodeColor[to] == WHITE) // If node is not yet visited.
      {
        nodeColor[to] = GREY; // Mark node as "in progress".
        customQueue.insert(to);
        previousVertex[to] = current;
        ptrShortestPath->at(to) = ptrShortestPath->at(current) + weight; // Calculate cost of moving to this node.
      }
      else // Select the most optimal route.
      {
        if (ptrShortestPath->at(to) > ptrShortestPath->at(current) + weight)
        {
          ptrShortestPath->at(to) = ptrShortestPath->at(current) + weight;
        }
      }
    }

    nodeColor[current] = BLACK;
  }

  return {};
} Up until this point, the implementation does not differ significantly from other examples you may find in books or on the internet. However, here is where the key aspect lies - getFirst() is the method that serves the main purpose as it determines the exact order of node traversal. BFS queue Let's take a closer look at the inner workings of our queue data structure. The queue interface for BFS is the simplest one. : bfsQueue.h#L11 #include <queue>
#include "pathFindingBase.h"

class bfsQueue : public pathFindingBase
{
private:
  queue<int> _queue;

public:
  virtual void insert(int node)
  {
    _queue.push(node);
  }

  virtual int getFirst()
  {
    int value = _queue.front();
    _queue.pop();
    return value;
  }

  virtual bool isEmpty()
  {
    return _queue.empty();
  }
}; In reality, we could simply replace the custom queue interface here with the standard C++ queue provided by the STL (Standard Template Library). However, the goal here is universality. Now, you only need to uncomment the line in the main method and run this algorithm: //bfsQueue customQueue; // UNCOMMENT TO USE BFS As a result, BFS finds the path 24<-19<-14<-9<-8<-7<-6<-1<-0. (0, 0) - (0, 1) - (0, 2) - (0, 3) - (0, 4)
                                       |
                                    (1, 4)
                                       |
                                    (2, 4)
                                       |
                                    (3, 4)
                                       |
                                    (4, 4) If we consider weights, the final cost of this path will be 11. However, remember that neither BFS nor DFS consider weights. Instead, they traverse all nodes in the graph, . hoping to find the desired node sooner or later DFS queue DFS doesn't look very different. We only replace the STD queue with a stack. : dfsStack.h#L11 #include <stack>
#include "pathFindingBase.h"

class dfsStack : public pathFindingBase
{
private:
  stack<int> _queue;

public:
  virtual void insert(int node)
  {
    _queue.push(node);
  }

  virtual int getFirst()
  {
    int value = _queue.top();
    _queue.pop();
    return value;
  }

  virtual bool isEmpty()
  {
    return _queue.empty();
  }
}; DFS finds the path 24<-23<-22<-21<-20<-15<-10<-5<-0 with a cost of 15 (it doesn't prioritize finding the optimal cost). Interestingly, it traverses in the opposite direction compared to BFS: (0, 0)
   | 
(1, 0) 
   |
(2, 0)
   |
(3, 0)
   | 
(4, 0) - (4, 1) - (4, 2) - (4, 3) - (4, 4) Dijkstra queue Now, Dijkstra's algorithm is the most well-known greedy search algorithm in a graph. Despite its known limitations (inability to handle negative paths, cycles, etc.), it remains popular and efficient enough. It is important to note that the getFirst() method in this implementation uses a greedy approach to select nodes for traversal. : dijkstraQueue.h#L17 #include <queue>
#include "pathFindingBase.h"

class dijkstraQueue : public pathFindingBase
{
private:
  vector<int> _queue;
  shared_ptr<vector<int>> _shortestPaths;

public:
  dijkstraQueue(shared_ptr<vector<int>> shortestPaths) : _shortestPaths(shortestPaths) { }

  virtual void insert(int node)
  {
    _queue.push_back(node);
  }

  virtual int getFirst()
  {
    int minimum = INF;
    int minimumNode = -1;

    for (int i = 0; i < _queue.size(); i++)
    {
      int to = _queue[i];
      int newDistance = _shortestPaths->at(to);

      if (minimum > newDistance) // Greedy selection: select node with minimum distance on every step
      {
        minimum = newDistance;
        minimumNode = to;
      }
    }

    if (minimumNode != -1)
    {
      remove(_queue.begin(), _queue.end(), minimumNode);
    }

    return minimumNode;
  }

  virtual bool isEmpty()
  {
    return _queue.empty();
  }
}; Dijkstra's algorithm finds the SHORTEST and most OPTIMAL path 24<-19<-18<-13<-12<-7<-6<-1<-0 with a cost of 10: (0, 0) -1- (0, 1)
             |
             1 
             |
           (1, 1) -1- (1, 2)
                         |
                         1 
                         |
                      (2, 2) -1- (2, 3)
                                    |
                                    1 
                                    |
                                  (3, 3) -1- (3, 4)
                                               |
                                               1 
                                               |
                                             (4, 4) A-Star The A-Star algorithm is particularly suited for cases where a path is sought in an Euclidean space with coordinates, such as maps. This is why it is widely used in games. It not only utilizes a "blind" greedy search based on minimal weights but also considers the Euclidean distance to the goal. As a result, it is usually much more efficient than Dijkstra's algorithm in practical scenarios (refer to for more details). : my other GitHub project aStarQueue.h#L18 class aStarQueue : public pathFindingBase
{
private:
  vector<int> _queue;
  shared_ptr<vector<int>> _shortestPaths;
  shared_ptr<Graph> _graph;
  int _finishX;
  int _finishY;

  /// <summary>
  /// Euclidian distance from node start to specified node id.
  /// </summary>
  int calcEuristic(int id)
  {
    return sqrt(
      pow(abs(
        _finishX > _graph->Nodes[id].X ?
        _finishX - _graph->Nodes[id].X :
        _graph->Nodes[id].X - _finishX), 2) +
      pow(abs(
        _finishY > _graph->Nodes[id].Y ?
        _finishY - _graph->Nodes[id].Y :
        _graph->Nodes[id].Y - _finishY), 2));
  }

public:
  aStarQueue(int finishX, int finishY, shared_ptr<Graph> graph, shared_ptr<vector<int>> shortestPaths)
    :
    _shortestPaths(shortestPaths),
    _graph(graph)
  {
    _finishX = finishX;
    _finishY = finishY;
  }

  virtual void insert(int node)
  {
    _queue.push_back(node);
  }

  virtual int getFirst()
  {
    int minimum = INF;
    int minimumNode = -1;

    for (int i = 0; i < _queue.size(); i++)
    {
      int to = _queue[i];
      int newDistance = _shortestPaths->at(to);
      int euristic = calcEuristic(to);

      if (minimum > newDistance + euristic)
      {
        minimum = newDistance + euristic;
        minimumNode = to;
      }
    }

    if (minimumNode != -1)
    {
      _queue.erase(remove(_queue.begin(), _queue.end(), minimumNode), _queue.end());
    }

    return minimumNode;
  }

  virtual bool isEmpty()
  {
    return _queue.empty();
  }
}; As a result, we obtain the same results as Dijkstra's algorithm because it provides the most optimal route. It is possible that this example might be too simplistic to demonstrate the real differences in performance among these algorithms. If you are interested in exploring the potential of these algorithms, please refer to , which implements these algorithms efficiently and employs a more visual approach with a wide range of test data. my other project Downsides However, there is a problem with our Dijkstra's and A-Star algorithms... The above implementation uses a vector (a dynamic array []) within our universal data structure. On every call to getFirst(), it takes O(N) time to find the required node in the vector. Consequently, assuming that the main algorithm also takes O(N*M) time, where M is the average number of neighbors, the overall complexity could become almost cubic. This would lead to significant performance degradation on large graphs. While this sample is useful for grasping the overall idea that all four algorithms are not fundamentally different, the devil lies in the details. Implementing all four algorithms efficiently using a universal data structure is challenging. For optimal performance (which is typically the primary concern in 99% of cases), more effort should be directed towards optimizations. For example, it makes a lot of sense to use a priority queue instead of an array for both Dijkstra's and A-Star algorithms. Speaking about optimizations of the A-Star algorithm, it makes a lot of sense to mention a few links that will open a deep world of optimizations: and . A* Optimizations and Improvements by Lucho Suaya JPS+: Over 100x Faster than A* by Steve Rabin Final word The goal of this article was to show how relevant all traversing algorithms are to each other. But an example of a graph used in this article is definitely too simplistic to demonstrate the real differences in performance among these algorithms. Therefore, use these examples primarily to gain a conceptual understanding rather than for production purposes. If you are interested in exploring the potential of these algorithms, please read my next article based on , which implements these algorithms efficiently and employs a more visual approach with a wide range of test data. my other project Stay tuned! Also published . here

BFS, DFS, Dijkstra, and A-Star Are Basically the Same Algorithm, I'll Show You Why

Unlocking IaC Part 3: Your First Terraform Deployment!

IaC পার্ট 3 আনলক করা: আপনার প্রথম টেরাফর্ম স্থাপনা!

IaC Teil 3 freischalten: Ihre erste Terraform-Bereitstellung!

Desbloqueo de IaC Parte 3: ¡Su primera implementación de Terraform!

Déverrouillage d'IaC, partie 3 : votre premier déploiement Terraform !

IaC भाग 3 को अनलॉक करना: आपका पहला टेराफ़ॉर्म परिनियोजन!

IaC のロックを解除するパート 3: 初めての Terraform デプロイメント!

IaC 파트 3 잠금 해제: 첫 번째 Terraform 배포!

Desbloqueando IaC Parte 3: Sua primeira implantação do Terraform!

Открываем IaC, часть 3: ваше первое развертывание Terraform!

IaC Bölüm 3'ün Kilidini Açma: İlk Terraform Kurulumunuz!

Mở khóa IaC Phần 3: Triển khai Terraform đầu tiên của bạn!

解锁 IaC 第 3 部分：您的首次 Terraform 部署！

Stories, News & Mentions about Initialized

Initialized’s Stories on HackerNoon

Initialized's News & Mentions