NNextis in the Image Recognition Industry

NNext

nnext

This paper is available on arxiv under CC 4.0 license. Authors: (1) Evan Ning, Milton Academy & evan_ning24@milton.edu; (2) David R. Kaeli, Department of Electrical and Computer Engineering & Northeastern University kaeli@ece.neu.edu. Table of Links Introduction Sieve Optimizations Mathematical Optimization Implementation Results and Discussions Conclusions, Source Code & References 1. Introduction Prime numbers are fundamental in number theory and play a significant role in various areas, from pure mathematics to practical applications. For example, public key encryption techniques, especially in cryptography (e.g., the Rivest Shamir Adelman encryption scheme (RSA) [1]), rely heavily on the novel properties of prime numbers. The degree of difficulty in factorizing very large numbers which are products of two prime numbers ensures the security of data encrypted using these methods. Even though prime numbers are fundamental in number theory, determining the primality of large numbers or generating long lists of prime numbers can be computationally challenging as primes are pseudorandomly distributed. Thus, despite several conjectures and theorems that lend insight into the distribution of prime numbers, there is no formula to compute the next prime. The prime sieve algorithm, more formally known as the "Sieve of Eratosthenes," is a well-known and efficient technique used to find prime numbers [2]. With the growing computational needs associated with prime enumeration tasks, traditional implementations of the Sieve algorithm remain a computational bottleneck, especially given the advances in multi-core processors. As the rate of data grows and computational demands rise, harnessing the power of multithread processing becomes imperative. Over the years, there have been prior studies that have delved into the challenge of parallelizing the Sieve of Eratosthenes. Some of these approaches try to exploit the capabilities of multicore processors, breaking down the computation task into chunks [3]. This approach lends itself to using parallelization libraries and middleware, including OpenMP (shared memory) and MPI (inter processor message queues) [4]. Some of the common drawbacks and challenges of parallel implementations are that too many threads accessing shared memory can lead to memory contention, causing bottlenecks and limiting the performance gains from parallelism. Furthermore, prior work has not adequately addressed scalability issues, such that when the prime number being searched for is very large, it eventually can exceed the limits of memory. Additionally, more optimizations can be made within each iteration with improvements in mathematical algorithms, which can lead to significant savings. We introduce a multithreaded implementation of the Segmented Sieve [3]. In our implementation, instead of handling large prime ranges in one iteration, the sieving process is broken down incrementally, which theoretically eliminates the challenges of working with large numbers, and can reduce memory usage, providing overall more efficient utilization over extended computations. In this work, we also explored some mathematical optimization to speed up computation. The code is implemented in POSIX threads C++ [6] and tested on a high-performance multi-core cluster [7]. We have been able to achieve a significant reduction in prime enumeration time, as well as a significant reduction in the associated memory footprint. 1.1 Sieve of Eratosthenes Prime numbers are hard to compute, which makes them indispensable in various fields, especially in cryptography. The security of many encryption systems depends on the computational difficulty of factorizing large numbers. The "Sieve of Eratosthenes," is an old, yet efficient, algorithm used to find all prime numbers up to a specified integer. The algorithm works by iteratively marking the multiples of each prime number given a range. The algorithm begins by creating a list of consecutive integers, from 2 up to n: (2, 3, 4, ..., n). Next, we set the current number, P, to the value 2. Then, remove all multiples of P beginning at P2 from the list, as all multiples of P less than P2 would have been removed in previous iterations already. For instance, the first time we run the algorithm, we remove all even numbers (except 2). Then, we remove all multiples of 3 (except 3), starting from 9 as 6 has already been removed, and so on. After each removal, we find the next number in the list after P that has not been removed. We set this new number to P and repeat the process. The Sieve of Eratosthenes can be expressed in pseudocode [5], as shown in Figure 1. The Sieve of Eratosthenes is especially efficient for computing all prime numbers up to a certain limit. Its time complexity is O(n log log n), making it one of the most efficient ways to find all primes up to a given limit n.

Memory Efficient Multithreaded Incremental Segmented Sieve Algorithm: Introduction

When the End Is Nigh

Debugging is an essential skill for any software developer. It allows us to find and fix errors in our code, improve quality and performance, and learn from our mistakes. One of the most common and powerful tools for debugging Python code is the . PDB is a module that provides an interactive command-line interface for inspecting and manipulating the state of a running program. Python Debugger (PDB) With PDB, we can set breakpoints, step through the code line by line, examine variables and expressions, modify values, and more. However, using PDB can also be cumbersome and tedious. To invoke PDB, we need to import the pdb module and insert a statement in our code where we want to pause the execution and enter the debugger. pdb.set_trace() import pdb

def add(a: int, b:int) -> int:
  pdb.set_trace()  # pause here and enter the debugger
  return a + b

print(add(1, 2)) This means we have to modify our source code every time we want to debug it, and remember to remove or comment out the pdb statements when we are done. Moreover, if we want to use a different debugger than PDB, such as IPython or PuDB, we have to change the import statement and the function call accordingly. Fortunately, introduced a new built-in function that simplifies this process: . The function is a convenient way to start a debugger at any point in our code without having to import anything or write debugger-specific code. Python 3.7 breakpoint() breakpoint() All we have to do is insert a statement where we want to pause the execution, and enter the debugger! breakpoint() In this article, we will learn what is, how to use it with PDB and other debuggers, and how to change its behavior with environment variables. breakpoint() Using breakpoint() When using PDB, we need to learn a couple of commands to interact with the debugger. There is a long list of commands PDB gives us, but we only need to know a few of them to get started. For example, if we want to print values, we use the command. p If we want to execute the next line of code, we use the or command. To continue execution until the next breakpoint, we use the or command. Finally, the or command shows us the code around the current line we are debugging. n next c continue l list Command Description p [variable_name] Print the value of an expression. or n next Continue execution until the next line in the current function is reached or it returns. or s step Execute the current line, and stop at the first possible occasion (either in a function that is called or in the current function). or c continue Continue execution, only stop when a breakpoint is encountered. or l list List the source code for the current file. or h help Prints a list of commands we can use with PDB. Let’s see how works. Below is a recursive function that calculates the factorial of a given number. I’ve added a statement to the function, so we can pause the execution and enter the debugger. breakpoint() breakpoint() # main.py

def factorial(number: int) -> int:
  if number < 0:
    raise ValueError("`n` must be non-negative.")
  elif number <= 1:
    return 1
  else:
    breakpoint()  # pause here and enter the debugger
    return number * factorial(number - 1)


# factorial(5) is: 5 * 4 * 3 * 2 * 1 = 120
print(factorial(5)) When we run this code, the program will stop at the statement and launch the default debugger, which is PDB by default. We can then use the PDB commands to inspect and manipulate the program state. breakpoint() https://replit.com/@DylanPaulus/factorial-breakpoint?embedable=true#main.py We can see that pauses the execution at the line where it is called. By using the commands we learned above, we can inspect the program state ( to see the value of ) and step through the code line by line ( ). breakpoint() p number n s Changing the Debugger Behavior One of the advantages of using over is that we can switch to a different debugger at any time. By setting the environment variable, we can tell Python which debugger we would like to use. breakpoint() pdb.set_trace() PYTHONBREAKPOINT For example, if we want to use IPython as our debugger, we can run: $ export PYTHONBREAKPOINT=IPython.core.debugger.set_trace
$ python3 main.py Another advantage of using is that we can disable all breakpoints in our code by setting the environment variable to 0. breakpoint() PYTHONBREAKPOINT This is useful when we want to run our code without entering the debugger, without having to remove or comment out all the statements. breakpoint() $ export PYTHONBREAKPOINT=0
$ python3 main.py End is a much-needed improvement over ! It gives us the ability to quickly debug our code and easily switch between different debuggers. breakpoint() pdb.set_trace()

breakpoint() and PDB Make It Faster and Easier to Debug in Python

Code sharing is an essential aspect of . programming With the rise of remote work and virtual collaboration, developers need reliable tools for code sharing that offer real-time communication, video and audio conferencing, and a friendly user interface. is one such example. Codeshare.io But today, we're going to roll up our sleeves and build our very own code-sharing playground using . Buckle up! 🎢 Dyte is a developer-friendly platform that offers powerful SDKs to build live experiences within our product. In this blog, we will walk you through the process of building a code-sharing platform with Dyte.io and ReactJs. Let’s start! 🏃 Dyte.io Step 0: Setting up Dyte account Before anything, we would need to set up a Dyte account. For this, first visit Dyte.io and then hit Start Building. On the next page, Sign in with Google or GitHub account to get your free Dyte account 🎉. You will find your API keys under the API Keys tab on the left sidebar. Keep your API keys secure and don’t share them with anyone. Step 1: Setting up the environment Hitting one more checkpoint before we dive into coding. We will be using Node.js, a popular JavaScript runtime environment, and create-react-app, a tool that generates a React project with a pre-configured setup. To get started, we will create three folders , , and . client server plugin Note: 🧑‍💻 If you are on Mac, you should turn off “AirPlay Receiver” in System Settings as it occupied Port 5000 by default. Just for reference, this is how our would look like at the end of this blog. final folder structure We will go ahead and install CLI using the command below. Dyte $ npm install -g @dytesdk/cli Going ahead with the authorization part and selecting the organization with the following commands. $ dyte auth login
$ dyte auth org For more information, visit . Dyte CLI Docs Step 2: Setting up a new Custom Plugin To start building a custom Dyte Plugin we will clone using the following command. Plugin template allows us to get started quicker. Dyte Plugin Template $ git clone https://github.com/dyte-in/react-plugin-template.git This template uses and allows us to create our own real-time plugins that work seamlessly with Dyte meetings. It has many interesting features to help us solve complex problems in minutes. Now, we will install the dependencies using the “npm install” command. @dytesdk/plugin-sdk $ npm install Next, we will add a couple of dependencies by running the following command. $ npm i @uiw/react-codemirror @codemirror/lang-javascript uuid Here, we are adding , which provides a pre-built Code Editor with language support. We are also installing UUID that will help us in generating UUIDs with just a function call. This will come in handy soon. react-codemirror Now that we have everything set up, we can use this command to start and test our Custom Plugin Setup. $ npm start Step 3: Trying out our new Custom Plugin To try using our new custom plugin, we will have to visit http://staging.dyte.io Here, we will be prompted to create a new meeting. It is super simple, just add your name and a meeting name and hit . On the next page, it will ask you to the meeting. Click on join and you’re in. Create join Find the button in the bottom-right corner, and click on it to reveal all existing plugins. We are interested in a plugin named, click on and it will reveal your plugin inside the meeting itself 🤯. Plugins launch We have everything ready with us. Now, we can get started with writing some actual code! Let’s begin with our Code Editor component. Step 4: Creating our Code Editor Let’s get started with creating our own code editor 🧑‍💻. For this we are going to first create a component and then use the package that we installed earlier. First, create a new in a file named inside and paste the following code. CodeMirror React Functional Component CodeEditor.js src/containers <CodeMirror    
   style={{ fontSize: "32px", textAlign: "left" }}    
   value={code}    
   onChange={handleCodeChange}    
   height="100vh"    
   width="100vw"    
   theme={'dark'}    
   extensions={[javascript({ jsx: true })]}/> CodeMirror component provides a pre-built Code Editor. It comes with various syntax highlighting features. Step 5: Handling Code Changes To work on handling the live code changes, let's first create a new state named code import { useEffect, useState, useRef } from "react";  
const [code, setCode] = useState("function add(a, b) { return a + b;}"); Now, we will create a function that will emit events whenever there is a change in our code in using function. handleCodeChange CodeMirror plugin.emit() Here, we are emitting an object, that has two properties. The first one is a randomly generated and the second one is our whole code. user id import { useEffect, useState, useRef } from "react";
import CodeMirror from '@uiw/react-codemirror';
import { javascript } from '@codemirror/lang-javascript';

const CodeEditor = ({ plugin }) => {
    const [code, setCode] = useState("function add(a, b) {return a + b;}");
		const [userId, setUserId] = useState()

    const handleCodeChange = async (code) => {
        plugin.emit(`CODE_CHANGE`, { code, user })
    }

    return (
        <>
            <CodeMirror
                style={{ fontSize: "32px", textAlign: "left" }}
                value={code}
                onChange={handleCodeChange}
                height="100vh"
                width="100vw"
                theme={'dark'}
                extensions={[javascript({ jsx: true })]}
            />
        </>
    );
}

export default CodeEditor; Step 6: Listening to Code Change Events We need to listen to the event when other people change the code. For this, we will use the function as shown below. The function accepts as a parameter and receives the code changes. plugin.on() event name One more thing to note here is that we have to update our current code only if it is sent by other users. For this we need to put a simple conditional statement if(data.user != userId){} import { useEffect, useState, useRef } from "react";
import CodeMirror from '@uiw/react-codemirror';
import { javascript } from '@codemirror/lang-javascript';
import {v4} from 'uuid';

const user = v4()

const CodeEditor = ({ plugin }) => {
    const [code, setCode] = useState("function add(a, b) {\n  return a + b;\n}");
		const [userId, setUserId] = useState()

     useEffect(() => {
        if (plugin) {
            const startListening = async () => {
                plugin.on(`CODE_CHANGE`, (data) => {
                    if(data.user != user) {
                        setCode(data.code)
                    } 
                });
            }
			startListening()
        }
    }, [plugin])


    const handleCodeChange = async (code) => {
        plugin.emit(`CODE_CHANGE`, { code, user })
    }

    return (
        <>
            <CodeMirror
                style={{ fontSize: "32px", textAlign: "left" }}
                value={code}
                onChange={handleCodeChange}
                height="100vh"
                width="100vw"
                theme={'dark'}
                extensions={[javascript({ jsx: true })]}
            />
        </>
    );
}

export default CodeEditor; In this component, we are creating a Code Editor using CodeMirror. Any changes to the editor emit an event to all users in the meeting, using function call. function takes and as arguments. CODE_CHANGE plugin.emit() emit eventName data In the next step, we need to import the CodeEditor component to file. Your file should look something like this. 👇 Main.tsx import { useDytePlugin } from '../context'
import CodeEditor from './CodeEditor';

const Main = () => {
  const plugin = useDytePlugin();

  return (
    <div style={{ height: "100%" }}>
        <CodeEditor plugin={plugin} />
    </div>
  )
}

export default Main Code for our “Collaborative Code Editor Plugin” 😉 is now ready. How did someone write the first code editor without a code editor 😂? Jokes aside, we are ready with our Plugin 🎉. To checkout, open up and follow along. Enter your name and meeting title to get in. Hit join meeting. Open up the plugin and you are good to go. staging.dyte.io Localhost Dev Step 7: Publishing our Component 🧑‍💻 Now, it’s time to publish our content, this is a simple process with . For this we have to first build our plugin then run command. Dyte CLI dyte plugins publish $ dyte plugins create
$ npm run build
$ cp dyte-config.json ./build/dyte-config.json
$ cd build
$ dyte plugins publish Step 8: Getting started with our Code Sharing Platform Now that we have built the plugin which will help us collaborate on code, we can get started with building the platform to use this plugin on. Let's start with client side. Inside the folder, we will setup a new project using and create our react app using the following command. client ReactJS create-react-app $ npx create-react-app . Next, let us install the dependencies of and by running the following command: Dyte code-editor $ npm i @dytesdk/react-ui-kit @dytesdk/react-web-core react-simple-code-editor 🎬 Now, let’s start our development server with npm start: $ npm start Step 9: Building the Layout Let us open file inside the folder. We will remove the contents of this file and add the following code snippet 👇. app.js src import Layout from './components/Layout'


function App() {
  return (
    <Layout />
  );
}

export default App; Next, we will write the component, we will be creating a layout with our logo, title and meeting UI. Layout We will use several libraries, including and PrismJS, for building a collaborative code editor and meeting UI. DyteMeeting import Meet from "./Meeting"


const Layout = () => {
  return (
		<>
      <div style={{ padding: "30px", display: "flex", justifyContent: "space-between", alignItems: "center" }}>
        <img src="https://dyte.io/blog/content/images/2021/09/Dyte-Logo.svg" height={"70px"}/>
        <span style={{ fontSize: "30px", color: "#3e75fd" }}>Collaborative Code Editor</span>
        <img style={{ opacity: "0"}} src="https://dyte.io/blog/content/images/2021/09/Dyte-Logo.svg" height={"80px"}/>
      </div>
      <div style={{ height: "88vh" }} ><Meet /></div>
    </>
  )
}

export default Layout Step 10: The Meeting Component 🧑‍💻 First, we need to create a few utility functions in a file client/src/utils/api.js const createMeeting = async () => {
    const resp = await fetch("http://localhost:3000/meetings", {
        method: "POST",
        body: JSON.stringify({ title: "New Code pair" }),
        headers: { "Content-Type": "application/json" }
    })
    const data = await resp.json()
    console.log(data)
    return data.data.id;
}

const joinMeeting = async (id) => {
    const resp = await fetch(`http://localhost:3000/meetings/${id}/participants`, {
        method: "POST",
        body: JSON.stringify({ name: "new user", preset_name: "group_call_host" }),
        headers: { "Content-Type": "application/json" }
    })
    const data = await resp.json()
    console.log(data)
    return data.data.token;
}

export { createMeeting, joinMeeting } These functions talk to our backend to create meetings and add participants. For meeting creation, we pass as an optional parameter. title And for adding participants, we pass parameter (optional), parameter (optional), and parameter (required) along with . name picture preset_name meetingId Time for our Meeting component. For this, we will use Dyte UI kit ✨ which makes it super easy to integrate live Audio/Video sharing in your application. Yes, these 10-15 lines of code do all the heavy lifting 🏋🏼‍♂️. import { useState, useEffect, useRef } from "react";
import { DyteMeeting, provideDyteDesignSystem } from "@dytesdk/react-ui-kit";
import { useDyteClient } from "@dytesdk/react-web-core";
import { createMeeting, joinMeeting } from "../utils/api";

const Meet = () => {
	const meetingEl = useRef();
	const [meeting, initMeeting] = useDyteClient();
	const [userToken, setUserToken] = useState();
	const [meetingId, setMeetingId] = useState();

	const createMeetingId = async () => {
		const newMeetingId = await createMeeting();
		setMeetingId(newMeetingId);
	};

	useEffect(() => {
		const id = window.location.pathname.split("/")[2];
		if (!id) {
			createMeetingId();
		} else {
			setMeetingId(id);
		}
	}, []);

	const joinMeetingId = async () => {
		if (meetingId) {
			const authToken = await joinMeeting(meetingId);
			await initMeeting({
				authToken,
				modules: {
					plugin: true,
					devTools: {
						logs: true,
						plugins: [
							{
								name: "Collaborative-code-editor",
								port: "5000",
								id: "<your-plugin-id>",
							},
						],
					},
				},
			});
			setUserToken(authToken);
		}
	};

	useEffect(() => {
		if (meetingId && !userToken) joinMeetingId();
	}, [meetingId]);

	useEffect(() => {
		if (userToken) {
			provideDyteDesignSystem(meetingEl.current, {
				theme: "dark",
			});
		}
	}, [userToken]);

	return (
		<>
			{userToken && meetingId ? (
				<DyteMeeting mode="fill" meeting={meeting} ref={meetingEl} />
			) : (
				<div>Loading...</div>
			)}
		</>
	);
};

export default Meet; We are ready with our Code Sharing Platform's UI now 🎉 Step 11: Getting the Backend Ready 🧑‍💻 Dyte provides a variety of powerful APIs that enhance the developer experience and meet a wide range of developer requirements. We can manage Dyte’s organizations, sessions, meetings, recordings, webhooks, live streaming, analytics, and much more. To simplify the process, we will use Express with Node to create a backend which will help with authentication, meeting creation, and adding participants.  ✨ To get started in the project folder, follow the following steps: $ mkdir server && cd server We’ll start with installing a couple of dependencies, cd into the 'server' directory, and use the following command. $ npm init -y
$ npm install express cors axios dotenv
$ npm install -g nodemon First, let's create a file to store our API key in . You can find these keys on Dyte Dashboard. .env server/src DYTE_ORG_ID=<ID>
DYTE_API_KEY=<KEY> Let’s also add a few scripts ✍️ that will help us run our application. Add the below lines in your file inside the tag. server package.json scripts "start": "node dist/index.js",
"dev": "nodemon src/index.js" Let's create our files and folders now. All our code will live inside the folder. Inside create another folder . server/src src utils Initialize a file inside and inside . Now let’s add our file in , which will hold our API secrets. index.js src dyte-api.js utils .env src Open up file and add the following lines to it. Replace the placeholder values with the API secrets from the Dyte Dashboard. src/.env DYTE_ORG_ID=<YOUR-DYTE-ORG-ID>
DYTE_API_KEY=<YOUR-DYTE-API-KEY> We can start writing code now. Let’s start with creating config for accessing Dyte APIs. axios Open up and put in the following code. utils/dyte-api.js This code will help to communicate with Dyte APIs and authentication. const axios = require('axios');

require('dotenv').config();

const DYTE_API_KEY = process.env.DYTE_API_KEY;
const DYTE_ORG_ID = process.env.DYTE_ORG_ID;

const API_HASH = Buffer.from(
  `${DYTE_ORG_ID}:${DYTE_API_KEY}`,
  'utf-8'
).toString('base64');

const DyteAPI = axios.create({
  baseURL: 'https://api.cluster.dyte.in/v2',
  headers: {
    Authorization: `Basic ${API_HASH}`,
  },
});

module.exports = DyteAPI; Next, we will write the routes. Our front end will communicate on these routes to create meetings and add participants to meetings. Let's open up and add the following code snippet.👇 index.js const express = require('express');
const cors = require('cors');
const DyteAPI = require('./utils/dyte-api')


const PORT = process.env.PORT || 3000;
const app = express();

app.use(cors("http://localhost:3001"));
app.use(express.json());


app.post('/meetings', async (req, res) => {
  const { title } = req.body
  const response = await DyteAPI.post('/meetings', {
    title,
  });
  return res.status(response.status).json(response.data);
});

app.post('/meetings/:meetingId/participants', async (req, res) => {
  const meetingId = req.params.meetingId
  const { name, picture, preset_name } = req.body
  const client_specific_id = `react-samples::${name.replaceAll(' ', '-')}-${Math.random().toString(36).substring(2, 7)}`;

    const response = await DyteAPI.post(`/meetings/${meetingId}/participants`, {
      name,
      picture,
      preset_name,
      client_specific_id,
    });

    return res.status(response.status).json(response.data);
});


app.listen(PORT, () => {
  console.log(`Started listening on ${PORT}...`)
}); Ta-da! 🎩✨ We did it! Now, we'll finally try out our code-sharing platform to collaborate while coding with our friends and teammates. With our shiny new Code editor and Dyte meeting all setup, we’ll finally try out our platform! To run the whole application locally: Inside client type PORT=3001 npm start Inside plugin type npm start Inside server type PORT=3000 npm run dev And there you have it, in-app video conferencing and collaboration with our own “Code Collaboration Plugin”. 🧑‍💻 You can try out the code-sharing platform . here Conclusion 🎉 Woohoo! You've made it to the end, my friend! I hope you've learned a thing or two today and had a good time following along the way. Together, we've built up a snazzy live pair programming and code-sharing platform, complete with in-app meetings, all with just a pinch of React and a dollop of Dyte. Talk about a recipe for success! We’ve got your back with our plugin templates and powerful SDKs, making it a breeze to jump right in and build your own collaborative masterpieces, just like the one we cooked up together today. So what are you waiting for? Head on over to and let your creative juices flow! Start building your own collaborative applications and you might just create the next big thing! 🚀 Dyte.io

How to Build a Live Code Sharing Platform With Dyte and ReactJs

Cómo construir una plataforma para compartir código en vivo con Dyte y ReactJs

Comment créer une plate-forme de partage de code en direct avec Dyte et ReactJs

डायट और रिएक्टज के साथ लाइव कोड शेयरिंग प्लेटफॉर्म कैसे बनाएं

Dyte と ReactJs を使用してライブ コード共有プラットフォームを構築する方法

Como construir uma plataforma de compartilhamento de código ao vivo com Dyte e ReactJs

Cách xây dựng nền tảng chia sẻ mã trực tiếp với Dyte và ReactJs

如何使用 Dyte 和 ReactJs 构建实时代码共享平台

Memoization is a term coined by Donald Michie in 1968, which is derived from the Latin word «memorandum» (to be remembered). In the context of software development, is a technique that saves the results of executing functions to avoid recalculations. memoization It’s quite simple: before calling a function, it first checks if there was the same function with the same arguments called before. If yes, then the stored result is returned, otherwise, the answer is calculated. The result is then stored and returned. In this article, we will use memoization to find Fibonacci numbers. Let me remind you that the Fibonacci sequence is defined so that each number is the sum of the two previous numbers. For instance, the first 6 terms of the Fibonacci sequence are 1, 1, 2, 3, 5, 8. First, let's define a recursion function that we can use to display the first numbers in the Fibonacci sequence: n const fib = (n) => {
	if (n === 1) {
		return 1;
	}

	if (n === 2) {
		return 1;
	}

	return fib(n - 1) + fib(n - 2);
} In the example above, we describe the beginning of the sequence - if the input value is 1 or 2, then the function returns 1. If the input value is greater than 2, the results of recursion function calls are returned, summing the previous two Fibonacci numbers. Now let's print the first 10 numbers: for (let i = 1; i < 11; i++) {
	console.log(`fib(${i}) = ${fib(i)}`);
}

fib(1) = 1
fib(2) = 1
fib(3) = 2
fib(4) = 3
fib(5) = 5
fib(6) = 8
fib(7) = 13
fib(8) = 21
fib(9) = 34
fib(10) = 55 Seems like it works just fine. Now let's try to display the first 40 numbers of the sequence: for (let i = 1; i < 41; i++) {
	console.log(`fib(${i}) = ${fib(i)}`);
}
...
fib(30) = 832040 
fib(31) = 1346269 
fib(32) = 2178309 
fib(33) = 3524578 
fib(34) = 5702887 
fib(35) = 9227465 
fib(36) = 14930352 
fib(37) = 24157817 
fib(38) = 39088169 
fib(39) = 63245986 
fib(40) = 102334155 Have you noticed it? — Calculations take much more time than for the first 10 numbers from the first example. This is because, with each subsequent calculation, we repeat the same work. Basically, a recursion approach to solving this kind of problem is considered bad practice due to the high time complexity of the algorithm. In this case, this solution is O(log N). When calculating a sequence for large numbers, this algorithm is inefficient. Now let’s see how the recursion function calculates each number: fib(1) = 1
fib(2) = 1
fib(3) = fib(1) + fib(2) = 2
fib(4) = fib(3) + fib(2) = 3
fib(5) = fib(4) + fib(3) = 5
fib(6) = fib(5) + fib(4) = 8 Here is the visual representation of it: Note that for we repeat the calculation of , and . If we had a way to these values after they have been computed, we could avoid repetition. This creates motivation for the . fib(6) fib(4) fib(3) fib(2) remember/save memoization method Now let's go over the implementation steps of the memoization method. Let's initialize the object that will store the cache: const cached = {}; Next, we need to define our . First, we check if the sequence number exists in the cache. If the number is there, then return the number corresponding to the number: memoization function const memoFib = (n) => {
	if (n in cached) {
		return cached[n];
	}
	...
} Next, we determine the two initial numbers of the sequence. If the function argument is 1 or 2, we should set the value to 1: const memoFib = (n) => {
	...
	if (n === 1) {
		return 1;
	}

	if (n === 2) {
		return 1;
	}
	...
} Next, let’s consider the recursive cases. If the argument is greater than 2, we need to set the value to the sum of the previous two numbers: const memoFib = (n) => {
	...
	const calculated = memoFib(n - 1) + memoFib(n - 2);
	...
} Finally, we save the value in our cache and return the value: const memoFib = (n) => {
	...
	cached[n]= calculated;

	return calculated;
} This is what the complete function looks like: const cached = {};

const memoFib = (n) => {
	if (n in cached) {
		return cached[n];
	}

	if (n === 1) {
		return 1;
	}

	if (n === 2) {
		return 1;
	}

	const calculated = memoFib(n - 1) + memoFib(n - 2);
	cached[n] = calculated;

	return calculated;

} Now, let's try to get the first 40 Fibonacci numbers with our new function: for (let i = 1; i < 41; i++) {
	console.log(`memoFib(${i}) = ${memoFib(i)}`);
} There is a more general way to memoize is to implement a function to create a memoized function. It's quite simple: const memo = (fn) {
	const cache = {};
	const slice = Array.prototype.slice;
	
	return function () {
		const args = slice.call(arguments);
		const key = JSON.stringify(args);

		if (cache[key]) {
			return cache[key]; 
		}
		
		const result = fn.apply(null, args);
		cache[key] = result;
		
		return result;
	};
} Using the function, we can achieve the same speed as our function: memo memoFib const memoFibV2 = memo((n) => {
	if (n === 1) {
		return 1;
	}

	if (n === 2) {
		return 1;
	}

	return memoFibV2 (n - 1) + memoFibV2 (n - 2);
});

for (let i = 1; i < 41; i++) {
	console.log(`memoFibV2(${i}) = ${memoFibV2(i)}`);
} Where can this be applied? You can use it in cases where you need to perform complex and lengthy calculations. Conclusion In this article, we have reviewed the in JavaScript. memoization method , it is shown how the unsophisticated implementation of the recursion function causes very slow calculations of a large number of numbers in the Fibonacci sequence. First We defined a new method in which we store the previous values ​​already computed in the cache, which results in a significant speedup of calculations. then , we discussed the function, which showed similar results to our function. Next memo memoFib I hope you found this article useful and exciting to read. Thank you for your time!

How Memoization Can Help You Boost Your Javascript Code

We’ve talked about why we chose to build Warp in Rust. Since making that decision, one thing that stands out is how productive we are as a team while still reaping the performance benefits of a systems-level language. in the past A big reason for that productivity is the borrow checker. By enforcing its rules at compile-time, Rust’s is able to make guarantees about the memory safety of our app, which lets us focus more of our energy on building the future of the terminal and less on chasing down use-after-free bugs. borrow checker At the same time, the borrow checker can be a source of frustration. Sometimes, you need to do something that breaks the rules but don’t want to throw safety out the window. Fortunately, the Rust standard library provides helpful types to let you do just that: break the rules! Shared Ownership Reference counting (Rc and Arc) Unique Borrows RefCell Locking Types (Mutex and RwLock) Atomics Shared Ownership The first borrow checker rule we’re going to break is single ownership: By default in Rust, every piece of data has a single owner, and when that owner goes out of scope, the data is cleaned up. This is great for ergonomics as you don’t have to worry about manually allocating and freeing memory! However, sometimes you don’t want data to have only a single owner. Maybe you want the data to pass through different parts of your program that will each run for different lengths and there’s no way to know how long in total the data needs to exist. Maybe you’re prototyping and don’t yet want to tackle ownership and lifetimes in a more concrete way. Whatever the reason, you really would like to have multiple owners for some data, so that it lasts as long as all of them combined. Reference Counting to the Rescue! Built into the Rust standard library are two types that provide shared ownership of the underlying data: and (short for ‘Reference counted’ and ‘Atomically reference counted’, respectively). Rc Arc Both of these types give shared ownership of the contained data by tracking the number of references and ensuring the data will last as long as there are any active references. They each implement and cloning increments the reference count while dropping one decrements it. The data is kept alive as long as there are references and only cleaned up once all of the clones have gone out of scope. For example, this snippet uses to share ownership of two pet objects between two owners: Clone Drop: Rc #[derive(Debug)]
struct Pet {
    name: String,
}

impl Pet {
    fn new(name: String) -> Self {
        Self { name }
    }
}

struct Person {
    pets: Vec<Rc<Pet>>,
}

fn main() {
    // Create two pets with shared ownership
    let cat = Rc::new(Pet::new("Tigger".into()));
    let dog = Rc::new(Pet::new("Chase".into()));

    // Create one person who owns both pets
    let brother = Person {
        pets: vec![cat.clone(), dog.clone()],
    };

    // Create another person who _also_ owns both pets
    let sister = Person {
        pets: vec![cat, dog],
    };

    // Even if one person gives up ownership, the other person still has shared ownership,
    // so the pets are kept around (yay!)
    drop(sister);
    println!("Pets: {:?}", brother.pets)
} Both types incur a small amount of runtime overhead to maintain the reference count. The key difference between them is that is thread safe, while isn’t. uses atomic operations to manage the reference count, which gives it a higher runtime cost but makes it safe to share between threads. If you’re only working in a single thread, then is the faster alternative. Arc Rc Arc Rc The last important fact about and is that they only allow you to get immutable references to the underlying data. Since they fundamentally represent shared data, allowing mutable references would violate Rust’s safety guarantees by allowing for data races and use-after-free errors. Rc Arc [2] Unique Borrows “But wait!,” you say, “What if I want to share mutable data between parts of my app?” Luckily, the next borrow checker rule we’re going to break is unique borrows: In order to mutate something, you need to have a unique (also called mutable) reference to the data. The borrow checker enforces that you can only have one mutable reference or any number of immutable references, but never a combination of the two, so you can’t ever mutate data that another part of the program is trying to read at the same time. This restriction works great most of the time, but we’re here to break the rules! Two cases where you might want to mutate data without having a mutable reference are: Caching an otherwise immutable calculation (i.e. memoization) The above shared ownership case with Rc or Arc For bending the compile-time borrowing rules, the compiler provides several helpful types, each with their own sets of drawbacks. All of them let you safely mutate data behind an immutable reference, using different approaches to make sure that your program is still safe. [3] RefCell First up is , which moves the enforcement of unique borrows from compile-time to runtime. Similar to , uses reference counting to track how many borrows are active while the program is running. If you ever try to take a mutable reference and another reference at the same time, will immediately panic! So when using , it’s up to you to make sure that your program doesn’t try to read and write the same data at the same time. RefCell Rc RefCell RefCell RefCell Here's an example of using to cache intermediate results for something that is otherwise immutable: RefCell struct FibonacciCalculator {
    cache: RefCell<HashMap<usize, usize>>,
}

impl FibonacciCalculator {
    /// Calculate the Nth fibonacci number, caching the result to prevent recalculation
    /// Note that this takes `&self`, not `&mut self`!
    fn calculate(&self, n: usize) -> usize {
        // Base case
        if n <= 2 {
            return 1;
        }

        // Check the cache
        if let Some(value) = self.cache.borrow().get(&n) {
            return *value;
        }

        // Calculate and cache the value
        let result = self.calculate(n - 1) + self.calculate(n - 2);

        self.cache.borrow_mut().insert(n, result);

        result
    }
} Also, the reference counting in is not thread safe, so it’s not possible to share data between threads. For mutating shared data between threads, we need to turn to our next tool. RefCell RefCell Locking Types The next two types are and , which both provide ways to access mutable references from an immutable reference in a thread-safe way. They do this by completely blocking the thread until it is safe to access the data. This provides a strong guarantee that the access is safe, but also has a major pitfall: Deadlocks. Deadlocks occur when two threads are blocked waiting for access to data that the other thread is holding. Similar to , it's up to you to make sure the logic of your program doesn't hold onto some data while waiting for access to other data leading to a deadlock. Mutex RwLock RefCell For example, the following snippet uses a Mutex to increment a counter in parallel in two new threads, then reads the final result from the original thread: // Create a shared, mutable counter
let counter = Arc::new(Mutex::new(0));

// Spawn one thread incrementing the counter
let counter1 = counter.clone();
let handle1 = thread::spawn(move || {
    for _ in 0..10 {
        *counter1.lock().unwrap() += 1;
    }
});

// Spawn another thread incrementing the counter
let counter2 = counter.clone();
let handle2 = thread::spawn(move || {
    for _ in 0..10 {
        *counter2.lock().unwrap() += 1;
    }
});

// Wait for the threads to complete
handle1.join().unwrap();
handle2.join().unwrap();

// Will write "Value: 20", since each thread incremented the counter 10 times.
println!("Value: {}", *counter.lock().unwrap()); The key difference between the two types is how they handle different kinds of access. A doesn’t care about whether you are trying to read or write the data, only a single thread can have access at a time. All other threads have to wait until the current consumer gives up their access. Mutex By contrast, follows Rust’s rules: Any number of threads can have read-only access to the underlying data or a single thread can have write access, but no combination. Attempting to obtain write access will block until there are no active readers and vice versa. RwLock The thread safe nature of these locking types makes them some of the most powerful ways to share mutable data, however it comes at a potentially significant performance cost: Locking the thread so that no other work can be done until the data is available. If our data is simple enough, the last type we’re going to look at can provide shared access across threads without needing to lock. Atomics are available for integer and boolean primitives. These types all provide methods to mutate or read the data as a single operation, so that nothing can happen in between and there is no possibility for data races. Atomic types For example, if you want to increment a counter, instead of reading the value, adding one, then writing the value, you would use the method that does all of that in a single block. fetch_add Atomics are often used as the building blocks for more complicated thread-safe sharing or one-off initialization. As mentioned above, Arc uses an atomic counter internally to manage the reference counting in a thread-safe way. The beauty of all of these types is that they provide a way to break the borrow checker rules while still maintaining Rust’s safety guarantees. Understanding which rules each type breaks is the key to knowing which tool you need. If you’re looking for shared ownership without copying, you want the reference counted types. If you’re looking for mutability without Rust’s strict mutable references, reach for interior mutability. And if you need shared mutable state, it’s not uncommon to use a combination of them: or are combinations for single- and multithreaded shared mutable ownership, respectively. Rc<RefCell<T>> Arc<Mutex<T>> If you’re interested in breaking more of Rust’s rules and pushing the terminal into the future, we’re hiring at Warp! Or if you’d just like to check out our Rust-based terminal, request early access below: Request early access to Warp First Published here

Make Your Rust Code More Rustic By Breaking Some Rules

Every programmer needs to know their algorithms and data structures. When studying them, you need to be sure to understand exactly what it does, what it's time and space complexity are they are that way, and be able to not only code it, but perform it by hand. This is what is all about. and why Essential Algorithms Welcome to the first installation of Essential Algorithms, where today, we'll be going over the Merge Sort. Merge Sort is one of the most reliably consistent and well-performing sorting algorithms for sorting large datasets, performing almost 40% fewer comparisons at it's than Quick Sort does on . So let's dig in and see what this algorithm is. worst average The Merge Sort Algorithm To start, let's take a simple array of numbers, that are out of order, which we want to sort: arr = [ , , , , , , , ] var 27 369 63 126 252 990 54 18 The Merge Sort algorithm can take these numbers and put them in order, small to big, or big to small, in consistent and efficient manner. Merge Sort takes a divide and conquer approach recursively; that is, it breaks the array into smaller and smaller ones by calling itself, until each one only has one element inside of it. Then, it compares two numbers at a time, puts them into order and returns them to itself, as it backs out of it's recursively called functions. So, our above array turns into the following sub-arrays: [[ , , , ],
[ , , , ]] 27 369 63 126 252 990 54 18 And again into: [[[ , ], [ , ]], [[ , ], [ , ]]] 27 369 63 126 252 990 54 18 And one final time: [[[[ ], [ ]], [[ ], [ ]]], [[[ ], [ ]], [[ ], [ ]]]] 27 369 63 126 252 990 54 18 With the elements sorted into sub-arrays, each pair needs to be evaluated, so that when merged together, the left value is smaller than the right one.  In this example, only the last pair of single-element arrays has a larger value on the left, so would be merged in as : [54], [18] [18,54] [[[ , ], [ , ]], [[ , ], [ , ]]] 27 369 63 126 252 990 18 54 With the smallest element held at index[0] of the most nested sub-arrays, the sub-arrays can now be merged, in order, in an efficient manner. To do so, compare the very first element of both arrays. Then, take the smaller element from the sub-arrays and put them into the array you are going to return, while taking them out of the arrays you are comparing. Thus, comparing the arrays and , we need only to look at the first item of the arrays. Since 27 < 63, 27 would be taken out of the first array, and added to the one we will return. This leaves us comparing . We need only to look at the first elements again, and see 63 is next, so our returning array is and we still have to compare. We then add 126, are left only with 369, so we add that. In all, the steps look like this: [27, 369] [63, 126] [369], [63,126] [27,63] [369], [126] [ , ] [ , ]
[]

[ ] [ , ]
[ ]

[ ] [ ]
[ , ]

[ ]
[ , , ]

[ , , , ] 27 369 63 126 369 63 126 27 369 126 27 63 369 27 63 126 27 63 126 369 After the second iteration, the arrays look like this: [[ , , , ], [ , , , ]] 27 63 126 369 18 54 252 990 The arrays are then merged again in the exact same way, comparing 27 to 18, then 27 to 54, then 63 and 54, so on, until the entire array is sorted and returned. When I mentioned earlier that each pair would need to be evaluated, and only would need to swap in the first step, both of those were held in their own arrays. This means that one can create a single function to compare the numbers in all instances, by comparing the element at index 0 of both arrays, and removing the lesser item when adding it to the returning array. This will be run until one of the arrays is empty, and the remaining elements of the other array will be appended to the end of the returning elements. [54],[18] The arrays will be merged together like that, recursively, until there is only one array left, and then it will be completely sorted. In a way, you can break it down into two fundamental steps: Merging 2 arrays: Take two arrays. Compare the first element of the two of them. The smaller of the elements should be removed from that array, and added to the end of the array we are returning. When all of the elements are removed from one array, just add the rest of the other one to the sorted array and return it. Divide and conquer: Take an array. Find the middle of it. Pass everything to the left of it into the divide and conquer function, and pass everything to the right of it to the divide and conquer function (so the function has been fed both halves of it), until there is only one. Then, start merging the 2 arrays. Time Complexity and Efficiency Merge Sort, much like Heap Sort, has a time complexity of in its best and worst case scenarios. The reason this doesn't change is because it performs all of the operations necessary to completely sort the list whenever it is called; it does not matter how sorted the list is when Merge Sort gets it. It can be already sorted, or it can be as unsorted as possible, but Merge Sort will still have to perform divisions of the list and comparisons. O(n*log(n)) O(log(n)) O(n) This contrasts with other algorithms like Bubble Sort, which iterate over the list recursively until it is sorted. If given an ideal or already sorted list, Merge Sort's performance at is significantly worse than Bubble Sort's . However, the more unsorted a list is, the more passes Bubble Sort must make over the entire array, so Bubble Sort's average and worst-case scenario is , making it terribly inefficient on average and worst cases. O(n*log(n)) O(n) O(n^2) But is Merge Sort's complexity quasilinear, with a complexity of This is because the longer the list is, the more operations you have to do. That is to say, the algorithm has from it requiring more time proportionate to the length of the array. The comes from the number of divisions of the array that takes place, just like the binary tree. In our example, we had 8 elements, we had to break them from arrays with lengths of 8 => 4 => 2 => 1 to begin to compare them. That's 3 divisions, and 2^3 is 8. By comparison, if we used 16 elements, we'd need to divide 16 => 8 => 4 => 2 => 1, which is 4 divisions, and 2^4 is 16! So here we can see the number of operations to split the arrays grows in a logarithmic fashion with respect to the length of the input. Because of that, it both grows at and , giving us the time complexity. why O(n*log(n))? O(n) O(log(n)) O(log(n)) O(n) O(n*log(n)) Merge Sort, when not sorted in place and implemented efficiently with space in mind, has a space complexity of , meaning the memory required to execute grows proportionally to the size of the input. This means, for every byte of input, one byte must be allocated in memory to hold the output. O(n) Code Examples Enough overview, let's look at a few examples. Both examples will use the same array as above. Reading the above overview, we can break down what we need to do into two basic steps: We need to recursively break the array into smaller sub arrays We need to merge the sub arrays together, sorting it as we fill it. With these 2 main steps, we can now write 2 different functions to implement the Merge Sort algorithm. Bear in mind, these examples are not going to be optimized for anything except code length and readability. I found many examples of the Merge Sort when I was first learning that contained several other parameters and variables, that while they worked and used space efficiently, they were harder to read when first starting out. Example 1: Python The first function we will write will be the one to break the supplied array into sub-arrays, and call our other function. Since this will be the parent function of the algorithm, I'll name this , which will be passed an unsorted list as it's only argument. It will handle breaking the arrays recursively, and passing them to the function that handles the actual merging and sorting, . merge_sort() merge() Since we want to break the unsorted list into 2 separate lists, we need to calculate the midpoint of the list. Dividing the list length in half works, but if you're using Python 3, the does floating-point operations, so use the to specify integer division. We can declare .  With our calculated mid point, we can then pass the halves of the array back into . / // mid = len(sorted)//2 merge_sort() mid = len(unsorted)// left = merge_sort(unsorted[:mid])
    right = merge_sort(unsorted[mid:]) : def merge_sort (unsorted) 2 Now, this works fine if the arrays are longer than 1 element, but once we get down to one, we're gonna start getting errors and infinite loops. So, we need to tell the program to only do this while there's more than one element in each unsorted list passed to the function. When an array or list of 2 or more elements is passed to the function, we want it to return to us the sorted list, which will be our next function. If only one element is passed, we want it to simply return that one element. So, we can wrap this all in an if/else statement, and add return statements, and this function will be complete: len(unsorted) > :
        mid = len(unsorted)// left = merge_sort(unsorted[:mid])
        right = merge_sort(unsorted[mid:])  
        result = merge(left, right) result : unsorted : def merge_sort (unsorted) if 1 2 return else return Calling the function before calling our function ensures that all of the divisions will be done before we start merging. With this in place, we can start to build the function. merge_sort() merge() merge() The function will take 2 arguments, the left and the right arrays. We'll make an empty to hold the returning results, that we'll populate with from the left and right lists. We will use a few while loops to perform this task. merge() sorted_list pop(0) While there are both the left and right unsorted lists, we need to compare the first element. The smaller of the two will be popped from the front of the list into the we will return. sorted_list sorted_list = [] len(left) > len(right) > : left[ ] <= right[ ]:
            sorted_list.append(left.pop( )) :
            sorted_list.append(right.pop( )) : def merge (left, right) while 0 and 0 if 0 0 0 else 0 So what happens when we are left with a list that is empty and one that isn't? Well, nothing. Since we don't know which list will run out first, or how long that list will be, after this loop is completed we need to add two more to check and see if the left and right are still populated, and add them to the before returning. This leaves us with the following function: sorted_list merge() sorted_list = [] len(left) > len(right) > : left[ ] <= right[ ]:
            sorted_list.append(left.pop( )) :
            sorted_list.append(right.pop( )) len(left) > :
        sorted_list.append(left.pop( )) len(right) > :
        sorted_list.append(right.pop( )) sorted_list : def merge (left, right) while 0 and 0 if 0 0 0 else 0 while 0 0 while 0 0 return So now, our entire file looks like this: mergesort.py len(unsorted) > :
        mid = len(unsorted)// left = merge_sort(unsorted[:mid])
        right = merge_sort(unsorted[mid:])  
        result = merge(left, right) result : unsorted sorted_list = [] len(left) > len(right) > : left[ ] <= right[ ]:
            sorted_list.append(left.pop( )) :
            sorted_list.append(right.pop( )) len(left) > :
        sorted_list.append(left.pop( )) len(right) > :
        sorted_list.append(right.pop( )) sorted_list : def merge_sort (unsorted) if 1 2 return else return : def merge (left, right) while 0 and 0 if 0 0 0 else 0 while 0 0 while 0 0 return And we can now test it out and see that it works: And there you go! An easy to read, short implementation in Python. Example 2: Javascript Again, in this example we write our first function in order to break the unsorted array into smaller sub-arrays, calling itself recursively until all of the divisions have been done, before calling the function. merge_sort() merge() Since we need to break this into 2 separate arrays, we again need to calculate the midpoint. Javascript will perform a floating-point calculation for odd numbers, so we'll use to round down, like Python did with the divisor. So, we can set a variable for our midpoint, make our left and right arrays, and pass them back to before calling . Math.floor() // merge_sort() merge() merge_sort = ( { mid = .floor(unsorted.length/ ) left = unsorted.slice( ,mid) right = unsorted.slice(mid,)
}) const ( ) function unsorted var Math 2 var 0 var This works just fine with arrays that are more than one element, but will cause an infinite loop and errors about undefined variables when you have only one item. We will have to wrap this in an if statement, performing this block of code only if has more than one element, and to just return the element if there's only one. We also need to call our function for the left and right arrays, and return that if there are more than one element in the array. unsorted merge() unsorted merge_sort = ( { (unsorted.length > ){ mid = .floor(unsorted.length/ ) left = merge_sort(unsorted.slice( ,mid)) right = merge_sort(unsorted.slice(mid,)) merge(left, right)
    } { unsorted
    }
}) const ( ) function unsorted if 1 var Math 2 var 0 var return else return Now we can start on our function. We'll initialize an array to hold our sorted results in, and while the left and right arrays both contain elements, we'll compare the first element of the two. Whichever element is smaller, will be shifted from that array, and pushed into the results. To keep the code short and compact, and with such a simple statement, I opted to use a one-line ternary operation. If you're not familiar with ternary operations, they're one-line if-statements structured like so: merge() if/else (condition to evaluate) ? ( ) : ( ) do this if true do this if false The expression that would be held in the if-statement is written out first, followed by the . The next expression is what to do if the evaluated statement is true, followed by a , and then what to do if the operation is false. I prefer these in JavaScript and don't like them in Python because I find the readability easier. In Python, the syntax is , leaving the statement to be evaluated in the middle, and the desired operations on each side. Personally, I don't find it as easy to read. It's one of those Python quirks I don't like, much like vs syntax. ? : (do this if true) if (statement to evaluate) else (do this if false) split() join() So, our first loop will contain the ternary function to move the elements between the arrays appropriately, and we'll need to add 2 more loops to check both the left and right arrays for remaining elements after the first loop, and add them to the sorted array. while while merge = ( { sorted = [] (left.length > && right.length > ){
        left[ ] < right [ ] ? sorted.push(left.shift()) : sorted.push(right.shift())
    } (left.length> ){
        sorted.push(left.shift())
    } (right.length> ){
        sorted.push(right.shift())
    } sorted
}) const ( ) function left, right var while 0 0 0 0 while 0 while 0 return Our complete file now looks like this: mergesort.js merge_sort = ( { (unsorted.length > ){ mid = .floor(unsorted.length/ ) left = merge_sort(unsorted.slice( ,mid)) right = merge_sort(unsorted.slice(mid,)) merge(left, right)
    } { unsorted
    }
}) merge = ( { sorted = [] (left.length > && right.length > ){
        left[ ] < right [ ] ? sorted.push(left.shift()) : sorted.push(right.shift())
    } (left.length> ){
        sorted.push(left.shift())
    } (right.length> ){
        sorted.push(right.shift())
    } sorted
}) const ( ) function unsorted if 1 var Math 2 var 0 var return else return const ( ) function left, right var while 0 0 0 0 while 0 while 0 return We can now test it in the browser console to make sure it works: Time Complexity Revisited Now that we have two different examples of the algorithm imposed in 2 different languages, we can come back and analyze it again to understand how and why Merge Sort's complexity is . Both of the examples above create two functions to perform the 2 major components of the algorithm. Both implementations use the parent function to recursively divide the lists it gets passed in half. Because of this, the actual function will be executed several times, and that number of times grows with the logarithm of the size of the list passed to it. So, we can say that the function itself has a complexity of . O(n*log(n)) merge_sort() merge_sort() merge_sort() O(log(n)) On the other hand, the function that gets called by has the task of taking the two inputs and combining them into a single output. The amount of time this will take is determined by the size of the inputs passed to it. So, we can say the function has a complexity of . The function, at gets called for every time gets called, and the number of times gets called is times, giving us our final complexity . merge() merge_sort() entirely merge() O(n) merge() O(n) once merge_sort() merge_sort() log(n) O(n*log(n)) The Merge Sort algorithm is consistently efficient, which is why it is used as the default sorting algorithm in languages like Java and Perl, and part of the hybrid Timsort used by Python. The Time Complexity stays constant, a good thing when considering performance and optimization, and due to the nature of it dividing the input in half recursively, the algorithm can be highly optimized if one has access to multiple CPUs at once. So there you have it, the Merge Sort. Hopefully after this, you have a solid grasp on how to do it, and even actually understand what actually means on an intuitive level. If you enjoyed this or learned something, share it! O(n*log(n))

Essential Algorithms: The Merge Sort

Impure and asynchronous; but still redux In my article, , I highlighted the simplicity of a reducer and the complexity that arises from the interaction between these reducers. And as we saw there, the sole purpose of a reducer is . Redux Lifecycle redux state manipulation What about actions? Who performs action manipulation? Middleware Borrowing words from , a middleware: redux.js.org is not a fundamental part of the Redux but is considered useful enough to be supported right in the core architecture is the suggested way to extend Redux with custom functionality and can be composed in a chain provides a third-party extension point between dispatching an action, and the moment it reaches the reducer has the same plural form (i.e. middlewares is not a word) almost always looks like: const middleware =  (mwApi) => (next) => (action) => {// do something}; This is just the curried form of a function that takes in 3 arguments and so I will write it in its original form: function middleware(mwApi, next, action) {// do something} Note : curry? confused? you might want to have a look at this 10 min read Middleware Input A middleware takes three arguments: mwApi An object with two methods — and — that is sometimes written as the ‘store’ in the middleware definition when it’s not. Nonetheless, we can use to get the complete state tree from the store and call with some action to ‘inject’ actions in the redux lifecycle. getState() dispatch() getState() dispatch() next As stated above, middleware can be composed in a chain. This composition is done by passing middleware functions to and connecting the returned store enhancer to the redux store. applyMiddleware The provided middleware create a pipeline of callbacks where the next middleware in the chain becomes the argument of a middleware. next The final middleware in the pipeline receives the store’s . This way, there is a single standard way to extend dispatch in the ecosystem. dispatch In other words: function (mwApi, next, action) {...}function (mwApi, next, action) {...}...function (mwApi, next, action) {...} mw1 mw2 mw_N_ const = createStore(rootReducer,applyMiddleware(mw1, mw2, ..., mw_N_)) store //>  mw1.next === mw2//>  mw2.next === mw3//>  ...//>  mw_N_.next === store.dispatch action An action object injected into the redux lifecycle by: store’s own dispatch method (after passing all middleware) a middleware directly calling mwApi.dispatch Once the action reaches the after passing the final middleware in the pipeline, it is dispatched to the reducers. dispatch() Middleware Output Middleware don’t return anything since they form a callback pipeline and their return values are completely ignored. Just FYI, nobody’s stopping you from returning a value of your liking from a middleware. Middleware Sideways Sometimes, we can choose not to call in certain conditions to stop the flow of down the pipeline and into the reducers. This can be thought of as dumping an into a “metaphorical” sink. next() action action function (mwApi, next, action) {// just don't call } mw next(action) A middleware can also modify the current action before passing it on or pass some other action in its place. function (mwApi, next, action) {if (action.type === FOO) {action.payload.push(foo)} mw if (action.type === BAR) {action = barAction()} next(action)} Even crazier, with access to the method, a middleware can decide to “translate” an into a series of other actions. dispatch() action function (mwApi, next, action) {if (action.type === FOO) {mwApi.dispatch(firstFooAction())mwApi.dispatch(secondFooAction())mwApi.dispatch(notFooAction())} else {next(action)}} mw Final Thoughts In redux, middleware are a force to reckon with. They offer us tremendous flexibility for action manipulation but they also carry heavy implicit risks. One misplaced call is all it takes to shutdown your entire app. next() We can easily abstract away complex behaviour in our apps, like: action logging async requests handling cookies persisting data analytics transmit data over websockets etc… Start exploring the different middleware by visiting the on the official redux website. Ecosystem page

Redux Middleware Lifecycle

Tutorial: SSR Split Testing and Analytics with React, Redux, and Next.js

Netflix because you watched feature Where are we at? This is what we did so far In , we downloaded our data from , did some EDA and created our user item matrix. The matrix has 671 unique users, 9066 unique movies and is 98.35% sparse part 0 MovieLens In , we described 3 of the most common recommendation methods: User Based Collaborative Filtering, Item Based Collaborative Filtering and Matrix Factorization part 1 In , we implemented Matrix Factorization through ALS and found similar movies part 2 In part 3, this part, we recommend movies to users based on what movies they’ve rated. We also make an attempt to clone Netflix’s “because you watched X” feature and make a complete page recommendation with trending movies Recommending Movies to users We pick up our code where we trained the ALS model from library. Previous code to load and process the data can be found in the previous posts in this series or on my . implicit Github model = implicit.als.AlternatingLeastSquares(factors=10,iterations=20,regularization=0.1,num_threads=4) model.fit(user_item.T) First let’s write a function that returns the movies that a particular user had rated def get_rated_movies_ids(user_id, user_item, users, movies):“””Input user_id: intUser ID user_item: scipy.Sparse MatrixUser item interaction matrix users: np.arrayMapping array between user ID and index in the user item       matrix movies: np.arrayMapping array between movie ID and index in the user item matrix Output movieTableIDs: python listList of movie IDs that the user had rated “””user_id = users.index(user_id) Get matrix ids of rated movies by selected user ids = user_item[user_id].nonzero()[1] Convert matrix ids to movies IDs movieTableIDs = [movies[item] for item in ids] return movieTableIDs movieTableIDs = get_rated_movies_ids(1, user_item, users, movies)rated_movies = pd.DataFrame(movieTableIDs, columns=[‘movieId’])rated_movies def get_movies(movieTableIDs, movies_table):“””Input movieTableIDs: python listList of movie IDs that the user had rated movies_table: pd.DataFrameDataFrame of movies info Output rated_movies: pd.DataFrameDataFrame of rated movies “”” rated_movies = pd.DataFrame(movieTableIDs, columns=[‘movieId’]) rated_movies = pd.merge(rated_movies, movies_table, on=’movieId’, how=’left’) return rated_movies movieTableIDs = get_rated_movies_ids(1, user_item, users, movies)df = get_movies(movieTableIDs, movies_table)df Now, let’s recommend movieIDs for a particular user ID based on the movies that they rated. def recommend_movie_ids(user_id, model, user_item, users, movies, N=5):“””Input user_id: intUser ID model: ALS modelTrained ALS model user_item: sp.Sparse MatrixUser item interaction matrix so that we do not recommend already rated movies users: np.arrayMapping array between User ID and user item index movies: np.arrayMapping array between Movie ID and user item index N: int (default =5)Number of recommendations Output movies_ids: python listList of movie IDs“”” user_id = users.index(user_id) recommendations = model.recommend(user_id, user_item, N=N) recommendations = [item[0] for item in recommendations] movies_ids = [movies[ids] for ids in recommendations] return movies_ids movies_ids = recommend_movie_ids(1, model, user_item, users, movies, N=5)movies_ids > [1374, 1127, 1214, 1356, 1376] movies_rec = get_movies(movies_ids, movies_table)movies_rec display_posters(movies_rec) movies_ids = recommend_movie_ids(100, model, user_item, users, movies, N=7)movies_rec = get_movies(movies_ids, movies_table)display_posters(movies_rec) Because You watched Let’s implement Netflix “Because You Watched” feature. It’s about recommending movies based on what you’ve watched. This is similar to what we already did, but this time, it’s more selective. Here’s how we will do it: We will choose random 5 movies that a user had watched and for each movie recommend similar movies to it. Finally, we display all of them in a one page layout def similar_items(item_id, movies_table, movies, N=5):“””Input-----item_id: intMovieID in the movies table movies\_table: DataFrame  
   DataFrame with movie ids, movie title and genre

 movies: np.array  
   Mapping between movieID in the movies\_table and id in the item user matrix

 N: int  
   Number of similar movies to return

 Output  
 -----  
 df: DataFrame  
   DataFrame with selected movie in first row and similar movies for N next rows  
 “””

# Get movie user index from the mapping array  
user\_item\_id = movies.index(item\_id)  
# Get similar movies from the ALS model  
similars = model.similar\_items(user\_item\_id, N=N+1)   
# ALS similar\_items provides (id, score), we extract a list of ids  
l = \[item\[0\] for item in similars\[1:\]\]  
# Convert those ids to movieID from the mapping array  
ids = \[movies\[ids\] for ids in l\]  
# Make a dataFrame of the movieIds  
ids = pd.DataFrame(ids, columns=\[‘movieId’\])  
# Add movie title and genres by joining with the movies table  
recommendation = pd.merge(ids, movies\_table, on=’movieId’, how=’left’)

return recommendation def similar_and_display(item_id, movies_table, movies, N=5): df = similar\_items(item\_id, movies\_table, movies, N=N)

 df.dropna(inplace=True)

 display\_posters(df) def because_you_watched(user, user_item, users, movies, k=5, N=5):“””Input-----user: intUser ID user\_item: scipy sparse matrix  
   User item interaction matrix

 users: np.array  
   Mapping array between User ID and user item index

 movies: np.array  
   Mapping array between Movie ID and user item index

 k: int  
   Number of recommendations per movie

 N: int  
   Number of movies already watched chosen

 “””

 movieTableIDs = get\_rated\_movies\_ids(user, user\_item, users, movies)  
   
 df = get\_movies(movieTableIDs, movies\_table)

 movieIDs = random.sample(df.movieId, N)

 for movieID in movieIDs:  
    title = df\[df.movieId == movieID\].iloc\[0\].title  
    print(“Because you’ve watched “, title)  
    similar\_and\_display(movieID, movies\_table, movies, k) because_you_watched(500, user_item, users, movies, k=5, N=5) “Because you watched “, ‘Definitely, Maybe (2008)’ ’ “Because you watched “, ‘Pocahontas (1995) “Because you watched “, ‘Simpsons Movie, The (2007)’ “Because you watched “, ‘Catch Me If You Can (2002)’ “Because you watched “, ‘Risky Business (1983)’ Trending movies Let’s also implement trending movies. In our context, trending movies are movies that been rated the most by users def get_trending(user_item, movies, movies_table, N=5):“””Input user_item: scipy sparse matrixUser item interaction matrix to use to extract popular movies movies: np.arrayMapping array between movieId and ID in the user_item matrix movies_table: pd.DataFrameDataFrame for movies information N: intTop N most popular movies to return “”” binary = user_item.copy()binary[binary !=0] = 1 populars = np.array(binary.sum(axis=0)).reshape(-1) movieIDs = populars.argsort()[::-1][:N] movies_rec = get_movies(movieIDs, movies_table) movies_rec.dropna(inplace=True) print(“Trending Now”) display_posters(movies_rec) get_trending(user_item, movies, movies_table, N=6) Trending Now Page recommendation Let’s put everything in a timeline method. The timeline method will get the user ID and display trending movies and recommendations based on similar movies that that user had watched. def my_timeline(user, user_item, users, movies, movies_table, k=5, N=5): get\_trending(user\_item, movies, movies\_table, N=N)

 because\_you\_watched(user, user\_item, users, movies, k=k, N=N) my_timeline(500, user_item, users, movies, movies_table, k=5, N=5) Trending Now “Because you watched “, ‘Definitely, Maybe (2008)’ “Because you watched “, ‘Pocahontas (1995)’ “Because you watched “, ‘Simpsons Movie, The (2007)’ “Because you watched “, ‘Catch Me If You Can (2002)’ “Because you watched “, ‘Risky Business (1983)’ Export trained models to be used in production At this point, we want to get our model into production. We want to create a web service where a user will provide a userid to the service and the service will return all of the recommendations including the trending and the “because you’ve watched”. To do that, We first export the trained model and the used data for use in the web service. import scipy.sparse scipy.sparse.save_npz(‘model/user_item.npz’, user_item) np.save(‘model/movies.npy’, movies)np.save(‘model/users.npy’, users)movies_table.to_csv(‘model/movies_table.csv’, index=False) from sklearn.externals import joblibjoblib.dump(model, ‘model/model.pkl’) Conclusion In this post, we recommend movies to users based on their movie rating history. From there, we tried to clone the “because you watched” feature from Netflix and also display Trending movies as movies that were rated the most number of times. In the next post, we will try to put our work in a web service, where a user requests movie recommendations by providing its user ID. Stay tuned!

Metflix: Because You Watched X

Where are we at? This is what we did so far In , we downloaded our data from , did some EDA and created our user item matrix. The matrix has 671 unique users, 9066 unique movies and is 98.35% sparse part 0 MovieLens In , we described 3 of the most common recommendation methods: ser ased ollaborative iltering, tem ased ollaborative iltering and atrix actorization part 1 U B C F I B C F M F In part 2, this part, we will implement atrix actorization through ALS and find similar movies M F Matrix Factorization We want to factorize our user item interaction matrix into a User matrix and Item matrix. To do that, we will use the lternating east quares (ALS) algorithm to factorize the matrix. We could write our own implementation of ALS like how it’s been done in or , or we can use the already available, fast implementation by . The ALS model here is from and can easily be added to your Python packages with or with Anaconda package manager with . A L S this post this post Ben Frederickson implicit pip conda import implicit model = implicit.als.AlternatingLeastSquares(factors=10,iterations=20,regularization=0.1,num_threads=4)model.fit(user_item.T) Here, we called ALS with the following parameters: 10 factors. The number of latent factors to be used 20 iterations 0.1 regularization. This regularization term is the lambda in the loss function 4 threads. This code can be parallelized which makes it super fast. it takes about 5 sec to train. One thing to note is that the input for the ALS model is a movie user interaction matrix, so we just have to pass the transpose of our item movie matrix to the model fit function Recommending similar movies It’s time to get some results. We want to find similar movies for a selected title. The implicit module offers a ready to use method that returns similar items by providing the movie index in the movie user matrix. However, we need to translate that index to the movie ID in the movies table movies_table = pd.read_csv(“data/ml-latest-small/movies.csv”)movies_table.head() def similar_items(item_id, movies_table, movies, N=5):“””Input item_id: intMovieID in the movies table movies_table: DataFrameDataFrame with movie ids, movie title and genre movies: np.arrayMapping between movieID in the movies_table and id in the item user matrix N: intNumber of similar movies to return Output recommendation: DataFrameDataFrame with selected movie in first row and similar movies for N next rows “”” Get movie user index from the mapping array user_item_id = movies.index(item_id) Get similar movies from the ALS model similars = model.similar_items(user_item_id, N=N+1) ALS similar_items provides (id, score), we extract a list of ids l = [item[0] for item in similars] Convert those ids to movieID from the mapping array ids = [movies[ids] for ids in l] Make a dataFrame of the movieIds ids = pd.DataFrame(ids, columns=[‘movieId’]) Add movie title and genres by joining with the movies table recommendation = pd.merge(ids, movies_table, on=’movieId’, how=’left’) return recommendation Let’s try it! Let’s see what similar movies do we get for a James Bond Movie: Golden Eye df = similar_items(10, movies_table, movies, 5)df Interesting recommendations. One thing to notice is that all recommended movies are also in the Action genre. Remember that there was no indication to the ALS algorithm about movies genres. Let’s try another example df = similar_items(500, movies_table, movies, 5)df Selected movie is a comedy movie and so are the recommendations. Another interesting thing to note is that recommended movies are in the same time frame (90s). df = similar_items(1, movies_table, movies, 5)df This is a case where the recommendations are not relevant. Recommending Silence of the Lambs for a user that just watched Toy Story does not seem as a good idea. Make it fancy So far, the recommendations are displayed in a DataFrame. Let’s make it fancy by showing the movie posters instead of just titles. This might help us later when we deploy our model and separate the work into Front End and Back End. To do that we will download movies that I found on Kaggle. We will need the following data: metadata movies_metadata.csv links.csv metadata = pd.read_csv(‘data/movies_metadata.csv’)metadata.head(2) From this metadata file we only need the and columns. imdb_id poster_path image_data = metadata[[‘imdb_id’, ‘poster_path’]]image_data.head() We want to merge this column with the movies table. Therefore, we need the links file to map between imdb id and movieId links = pd.read_csv(“data/links.csv”)links.head() links = links[[‘movieId’, ‘imdbId’]] Merging the ids will be done in 2 steps: First merge the poster path with the mapping links Then merge with movies_table But first we need to remove missing imdb ids and extract the integer ID image_data = image_data[~ image_data.imdb_id.isnull()] def app(x):try:return int(x[2:])except ValueError:print x image_data[‘imdbId’] = image_data.imdb_id.apply(app) image_data = image_data[~ image_data.imdbId.isnull()] image_data.imdbId = image_data.imdbId.astype(int) image_data = image_data[[‘imdbId’, ‘poster_path’]] image_data.head() posters = pd.merge(image_data, links, on=’imdbId’, how=’left’) posters = posters[[‘movieId’, ‘poster_path’]] posters = posters[~ posters.movieId.isnull()] posters.movieId = posters.movieId.astype(int) posters.head() movies_table = pd.merge(movies_table, posters, on=’movieId’, how=’left’)movies_table.head() Now that we have the poster path, we need to download them from a website. One way to do it is to use the to get movie posters. However, we will have to make an account on the website, apply to use the API and wait for approval to get a token ID. We don’t have time for that, so we’ll improvise. TMDB API All movie posters can be accessed through a base URL plus the movie poster path that we got, and using HTML module for Python we can display them directly in Jupyter Notebook. from IPython.display import HTMLfrom IPython.display import display def display_recommendations(df): images = ‘’for ref in df.poster_path:if ref != ‘’:link = ‘ + refimages += “<img style=’width: 120px; margin: 0px; \float: left; border: 1px solid black;’ src=’%s’ />” \% linkdisplay(HTML(images)) http://image.tmdb.org/t/p/w185/' df = similar_items(500, movies_table, movies, 5)display_recommendations(df) Recommendations for `Mrs Doubtfire` Put all of it into one small method def similar_and_display(item_id, movies_table, movies, N=5): df = similar\_items(item\_id, movies\_table, movies, N=N)

display\_recommendations(df) similar_and_display(10, movies_table, movies, 5) Recommendations for `Golden Eye` Conclusion In this post we implemented ALS through the implicit module to find similar movies. Additionally we did some hacking to display the movie posters instead of just DataFrame. In the next post we will see how to make recommendations for users depending on what movies they’ve seen. We will also see how we can set up an evaluation scheme and optimize the ALS parameters for. Stay tuned!

Metflix: How to recommend movies — Part 2

An overview about: anonymous, higher-order, closures, concurrent, deferred, and other kinds of Golang funcs. This post is a summary for the different kind of funcs in Go. I’ll go into more detail in the upcoming posts because they deserve more. This is just a start. What is a function? A function is a separate and reusable block of code which can be runned again and again. Functions may accept input values and they may return output values. Why do we need functions? Increasing the readability, testability and maintainability Making some part of a code separately executable Composing things from smaller things Adding behavior to types Organizing the code To be DRY Named Funcs A named func has a name and declared at the package-level — . outside of the body of another func 👉 I explained them in detail in my another post, here . This is a named func: Len func takes a string and returns and int Variadic funcs A variadic func accepts variable number of input values — zero or more. Ellipsis (three-dots) prefix in front of an input type makes a func variadic. Declares a variadic func with a variadic input param of strings named as `names`. Example Let’s create a Logger which the verbosity and the prefix options can be changed at the run-time using the option pattern: type Logger struct {
  verbosity
  prefix string
} SetOptions applies options to the Logger to change its behavior using a variadic option param: func (lo *Logger) SetOptions(opts ...option) {
  for _, applyOptTo := range opts {
    applyOptTo(lo)
  }
} Let’s create some funcs which return option func as a result in a closure to change the Logger’s behavior: func HighVerbosity() option {
  return func(lo *Logger) {
    lo.verbosity = High
  }
}

func Prefix(s string) option {
  return func(lo *Logger) {
    lo.prefix = s
  }
} Now, let’s create a new Logger with the default options: logger := &Logger{} Then provide options to the logger through the variadic param: logger.SetOptions(
  HighVerbosity(), 
  Prefix("ZOMBIE CONTROL"),
) Now let’s check the output: logger.Critical("zombie outbreak!")

// [ZOMBIE CONTROL] CRITICAL: zombie outbreak!

logger.Info("1 second passed")

// [ZOMBIE CONTROL] INFO: 1 second passed See the working code with the explanations inside 👉 To learn more about them check out my post about variadic funcs, here . Methods When you attach a func to a type the func becomes a of that type. So, it can be called through that type. Go will pass the type ( to the method when it’s called. method the receiver) Example Create a new counter type and attach a method to it: type Count int

func (c Count) Incr() int {
  c = c + 1
  return int(c)
} The method above is similar to this func: func Incr(c Count) int Not exactly true but you can think of the methods as above Value receiver The value of the Count instance is copied and passed to the method when it’s called. var c Count; c.Incr(); c.Incr()

// output: 1 1 It doesn’t increase because “c” is a value-receiver. Pointer receiver To increase the counter’s value you need to attach to — *Count. the Incr func the Count pointer type func (c *Count) Incr() int {
  *c = *c + 1
  return int(*c)
}

var c Count

c.Incr(); c.Incr()

// output: 1 2 There are more examples from my previous posts: and . here here Interface methods Let’s recreate the above program using the interface methods. Let’s create a new interface named as : Counter type Counter interface {
 Incr() int
} onApiHit func below can use any type which has an method: Incr() int func onApiHit(c Counter) {
 c.Incr()
} Just use our dummy counter for now — : you can use a real api counter as well dummyCounter := Count(0)

onApiHit(&dummyCounter)

// dummyCounter = 1 Because, the Count type has the Incr() int method on its method list, onApiHit func can use it to increase the counter — I passed a pointer of dummyCounter to onApiHit, otherwise it wouldn’t increase the counter. The difference between the interface methods and the ordinary methods is that the interfaces are much more flexible and loosely-coupled. You can switch to different implementations across packages without changing any code inside onApiHit etc. First-class funcs First-class means that funcs are value objects just like any other values which can be stored and passed around. Funcs can be used with other types as a value and vice-versa Example: The sample program here processes a sequence of numbers by using a slice of as an input param value to a func named “ ”. Crunchers crunch Declare a new “ ” which takes an int and returns an int. user-defined func type : This means that any code that uses this type accepts a func with this exact signature type Cruncher func(int) int Declare a few cruncher funcs: func mul(n int) int {
  return n * 2
}

func add(n int) int {
  return n + 100
}

func sub(n int) int {
  return n - 1
} Crunch func processes a series of ints using : a variadic Cruncher funcs func crunch(nums []int, a ...Cruncher) (rnums []int) {

  // create an identical slice
  rnums = append(rnums, nums...)

  for _, f := range a {
    for i, n := range rnums {
      rnums[i] = f(n)
    }
  }

  return
} Declare an int slice with some numbers and process them: nums := []int{1, 2, 3, 4, 5}

crunch(nums, mul, add, sub) Output: [101 103 105 107 109] Anonymous funcs A noname func is an anonymous func and it’s declared inline using . It becomes more useful when it’s used as a closure, higher-order func, deferred func, etc. a function literal Signature A named func: func Bang(energy int) time.Duration An anonymous func: func(energy int) time.Duration They both have the same signature, so they can be used interchangeably: func(int) time.Duration Example Let’s recreate the cruncher program from using the anonymous funcs. Declare the crunchers as anonymous funcs inside the main func. the First-Class Funcs section above func main() {

crunch(nums,
    func(n int) int { 
      return n * 2 
    },
    func(n int) int {
      return n + 100
    },
    func(n int) int {
      return n - 1 
    })

} This works because, crunch func only expects the Cruncher func type, it doesn’t care that they’re named or anonymous funcs. To increase the readability you can also assign them to variables before passing to crunch func: mul := func(n int) int {
  return n * 2
}

add := func(n int) int {
  return n + 100
}

sub := func(n int) int {
  return n - 1
}

crunch(nums, mul, add, sub) Higher-Order funcs An higher order func may take one or more funcs or it may return one or more funcs. Basically, it uses other funcs to do its work. Split func in the closures section below is a higher-order func. It returns a as a result. tokenizer func type Closures A closure can remember all the surrounding values where it’s defined. One of the benefits of a closure is that it can operate on the captured environment as long as you want — beware the leaks! Example Declare a new func type that returns the next word in a splitted string: type tokenizer func() (token string, ok bool) Split func below is which splits a string by a separator and returns a which enables to walk over the words of the splitted string. an higher-order func closure The returned closure can use the surrounding variables: “tokens” and “last”. Let’s try: const sentence = "The quick brown fox jumps over the lazy dog"

iter := split(sentence, " ")
 
for {
  token, ok := iter()
  if !ok { break }

  fmt.Println(token)
} Here, we use the split func to split the sentence into words and then get and put it into the iter variable. a new iterator func as a result value Then, we start an infinite loop which terminates only when the iter func returns false. Each call to the iter func returns the next word. The result: The
quick
brown
fox
jumps
over
the
lazy
dog Again, more explanations are inside. Deferred funcs A deferred func is only executed after its parent func returns. Multiple defers can be used as well, they run as a , one by one. stack Example Go runtime will save any passed params to the deferred func at the time of registering the defer — . not when it runs Declare a dummy func that registers a deferred closure. : It also uses a named result value “n” to increase the passed number for the second time func count(i int) (n int) {

  defer func() {
    n = n + i
  }(i)

  i = i * 2
  n = i

  return
} Let’s try: count(10)

// output: 30 What happened? Parse the visual following the numbers (on the left): 1, 2, 3 . In some situations defer can help you to change the result value before the return by using the named result values as seen in the example. 👉 To learn more about them check out my post about Go defers, here . Concurrent funcs go func() runs the passed func concurrently with the other goroutines. A goroutine is a lighter thread mechanism which allows you to structure concurrent programs efficiently. The main func executes in the main-goroutine. Example Here, “start” anonymous func becomes a concurrent func that doesn’t block its parent func’s execution when called with “go” keyword: start := func() {
  time.Sleep(2 * time.Second)
  fmt.Println("concurrent func: ends")
}

go start()

fmt.Println("main: continues...")
time.Sleep(5 * time.Second)
fmt.Println("main: ends") Output main: continues...
concurrent func: ends
main: ends Main func would terminate without waiting for the concurrent func to finish if there were no sleep call in the main func: main: continues...
main: ends Other Types Recursive funcs You can use recursive funcs as in any other langs, there is no real practical difference in Go. However, you must not forget that each call creates a new . But, in Go, stacks are dynamic, they can shrink and grow depending on the needs of a func. If you can solve the problem at hand without a recursion prefer that instead. call stack Black hole funcs A black hole func can be defined multiple times and they can’t be called in the usual ways. They’re sometimes useful to test a parser: see . this func _() {}
func _() {} Inlined funcs Go linker places a func into an executable to be able to call it later at the run-time. Sometimes calling a func is an expensive operation compared to executing the code directly. So, the compiler injects func’s body into the caller. To learn more about them: Read and and and . this this this this External funcs If you omit the func’s body and only declare its signature, the linker will try to find it in an external func that may have written elsewhere. As an example, just declared with a signature and then . Atan func here implemented in here 💓 Share this post with your friends. Thank you! 💓 I’m also creating an online course for Go → ← Join to my newsletter “ Let’s stay in touch weekly for new tutorials and tips “ Read more: 🐣 Go Funcs — Baby-Gopher’s Visual Guide Originally published at blog.learngoprogramming.com on November 9, 2017.

The Zoo of Go Functions

Azure Functions custom deployment scripts in C# Azure Functions utilizes the same “engine” for deployments as Azure App Services, Kudu, by default when you hook up continuous deployment from i.e. GitHub Kudu will handle everything for you and it will just work — you’ll commit your code and shortly after your code is live. In this post I’ll walk you through the process of overriding the default deployment process triggered when a change occurs in the deployment source. I’ll use deploying using C# as an example, but basically the sky is the limit here and you could use F# with FAKE, JavaScript with Node, PowerShell or as default plain old batch scripts — basically whatever tool you like. Why would you do this? Well basically it enables more advanced deployment scenarios like custom paths, private NuGet feeds without committing sensitive information to repository, just to name a few. Standard deployment So lets first see what a standard Kudu batch deployment script for Azure Functions could look like below (don’t worry, there will be a summary so you can scroll past it😎) If you remove the error handling, bootstrapping of tools and initial setup of variables the important line is this one "%KUDU_SYNC_CMD%" -v 50 -f "%DEPLOYMENT_SOURCE%" -t "%DEPLOYMENT_TARGET%" -n "%NEXT_MANIFEST_PATH%" -p "%PREVIOUS_MANIFEST_PATH%" -i ".git;.hg;.deployment;deploy.cmd" So what this basically does is syncs the files in the repository with what’s running on the Function App, excluding repository system files and deployment scripts — deleting any files no longer present, adding any new files and overwriting any changes files. Overriding default script Overriding the default behavior is actually almost brilliantly simple, add a file in the root of the repository, the file can control many aspects of deployment out of the box without needing custom scripts, i.e. overriding Azure Functions Script root in deployment source(i.e. GIT repository), but the setting we’re interested in here is the setting which lets us set which command should be executed on deployment. .deployment .deployment command No each time a deployment is triggered either by a commit or initial deploy — it’ll look for a file called and execute it. deploy.cmd Bootstrapping Cake So Cake isn’t avail by default on Azure App Services so we need to make sure it’s in-place before we can deploy using C#, we do this in our custom deploy.cmd What this does is creates a directory, fetches and installs Cake script runner from NuGet and then executes which is our C# deployment script. Tool deploy.cake Deploying with Cake So the equivalent of the standard batch deployment script could in Cake look something like below The directive fetches KuduSync from NuGet (whereas the default fetches from NPM) #tool The directive fetches the addin which is a Cake addin I’ve written which abstracts several things in the Kudu environment in from C# easily accessible via typed objects, properties and methods, i.e. the KuduSync utility. #addin Cake.Kudu We could then just have written and it’ll done the same thing as the batch script, but as a preparation for the future(and because it’s the right way to do it 😉) I utilize the Cake task runner. Kudu.Sync("./src"); Despite that it’s not that much code — and IMHO allot more readable and familiar code for a C# developer vs. a batch script. And nicer log output is just a nice bonus. Conclusion The Cake script in this post is a pretty basic and naive one, when you realize you got the full power of C#, .NET Framework and the hundreds of Cake addins avail it’s really powerful story and I will do follow up posts with more advanced scenarios. You can read more about Cake at and there besides Cake’s own documentations — also most addins API’s are documented including . cakebuild.net Cake.Kudu As always feel free to ping me if you have any feedback, praise or questions. You’ll find a complete code from this post at below GitHub repository github.com azurevoodoo/DeliveringFunctionswithCake Deploying Azure Functions using C# via Cake scrips

⚡Delivering Functions with Cake🍰

What's Next in the Journey of AI? Neuro-Symbolic AI

How to Build a Request Access Approval System Using Next.js

Runes: The Next Big Step in Bitcoin's Evolution?

**MAJURO, Marshall Islands, July 16th, 2024/Chainwire/--**Multipool, a leading innovator in the blockchain and cryptocurrency industry announces strategic partnership with Tokinvest with the goal of transforming tokenized real-world asset trading. This partnership aims to take real-world asset (RWA) trading to the next level with an end-to-end dual market solution for RWA token offerings, secondary market trading, and liquidity provision. The partnership between Multipool and Tokinvest represents a key advancement in the tokenized RWA ecosystem. Our collaboration will harness RWA tokenization and trading to enhance financial inclusion, transparency, and liquidity for investors. Working With The Best Together, Multipool and Tokinvest will centralize liquidity pools using decentralized technology, reducing market-making costs. Additionally, the goal is to create global portability for RWAs, enabling listings on the Tokinvest centralized marketplace and regulated platforms worldwide through the decentralized Multipool protocol. “We’re thrilled to be collaborating with the RWA industry powerhouse Tokinvest, the first RWA exchange to leverage the groundbreaking decentralized capabilities of the Multipool protocol. Multipool centralizes currently dispersed liquidity with the potential of a globally shared order book, making it the ideal platform for Tokinvest to thrive.” - Steve Murray, Core Contributor at Multipool. "We are excited to partner with Multipool to develop a robust dual-market solution for real-world assets. By integrating our centralized trading platform with Multipool's decentralized infrastructure, we can offer enhanced liquidity for the secondary market trading of tokenized real-world assets." - Scott Thiel, CEO of Tokinvest. Looking forward Secondary trading for tokenized real-world assets requires a new approach. Acting as an infrastructure partner, Multipool's groundbreaking protocol opens the path for accelerated growth of this trillion-dollar market. Multipool’s fully on-chain order book and matching engine permit shared liquidity across trading venues. For a full demonstration of how the Multipool protocol works, users can contact Multipool’s press department listed below. To learn more about Multipool and its features, users can visit: Website Telegram X CMC-Community About Multipool Multipool is a cutting-edge decentralized exchange (DEX) transforming the trading landscape for real-world assets (RWAs) and cryptocurrencies. Multipool is designed for fairness and equality, featuring a fully decentralized on-chain order book, deep liquidity through dynamic bracket pools, and seamless trading of RWAs and cryptocurrencies. Utilizing world-class innovations including industry-first FIX APIs, low latency networks, zero price impact auctions, trustless RFQs, peer-to-peer repo lending, and MEV bot protection, Multipool sets a new standard in DeFi trading. Experience unparalleled efficiency and security in your trading journey with Multipool – The DEX with CEX appeal. https://www.multipool.finance/ About Tokinvest Tokinvest is a pioneering marketplace that connects real-world asset issuers with investors globally. Our advanced platform simplifies the investment process by creating virtual tokens representing rights to assets and providing comprehensive lifecycle services from ideation to trading to asset servicing. Headquartered in Dubai, we leverage the region’s favourable regulatory environment to offer all investors access to the most desirable assets. https://tokinvest.capital/ Contact Public Relations Manager Angie Hermosa Multipool press@multipool.finance This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. **MAJURO, Marshall Islands, July 16th, 2024/Chainwire/--**Multipool, a leading innovator in the blockchain and cryptocurrency industry announces strategic partnership with Tokinvest with the goal of transforming tokenized real-world asset trading. This partnership aims to take real-world asset (RWA) trading to the next level with an end-to-end dual market solution for RWA token offerings, secondary market trading, and liquidity provision. The partnership between Multipool and Tokinvest represents a key advancement in the tokenized RWA ecosystem. Our collaboration will harness RWA tokenization and trading to enhance financial inclusion, transparency, and liquidity for investors. Working With The Best Together, Multipool and Tokinvest will centralize liquidity pools using decentralized technology, reducing market-making costs. Additionally, the goal is to create global portability for RWAs, enabling listings on the Tokinvest centralized marketplace and regulated platforms worldwide through the decentralized Multipool protocol. “We’re thrilled to be collaborating with the RWA industry powerhouse Tokinvest, the first RWA exchange to leverage the groundbreaking decentralized capabilities of the Multipool protocol. Multipool centralizes currently dispersed liquidity with the potential of a globally shared order book, making it the ideal platform for Tokinvest to thrive.” - Steve Murray, Core Contributor at Multipool. “We’re thrilled to be collaborating with the RWA industry powerhouse Tokinvest, the first RWA exchange to leverage the groundbreaking decentralized capabilities of the Multipool protocol. Multipool centralizes currently dispersed liquidity with the potential of a globally shared order book, making it the ideal platform for Tokinvest to thrive.” - Steve Murray, Core Contributor at Multipool. "We are excited to partner with Multipool to develop a robust dual-market solution for real-world assets. By integrating our centralized trading platform with Multipool's decentralized infrastructure, we can offer enhanced liquidity for the secondary market trading of tokenized real-world assets." - Scott Thiel, CEO of Tokinvest. "We are excited to partner with Multipool to develop a robust dual-market solution for real-world assets. By integrating our centralized trading platform with Multipool's decentralized infrastructure, we can offer enhanced liquidity for the secondary market trading of tokenized real-world assets." - Scott Thiel, CEO of Tokinvest. Looking forward Secondary trading for tokenized real-world assets requires a new approach. Acting as an infrastructure partner, Multipool's groundbreaking protocol opens the path for accelerated growth of this trillion-dollar market. Multipool’s fully on-chain order book and matching engine permit shared liquidity across trading venues. For a full demonstration of how the Multipool protocol works, users can contact Multipool’s press department listed below. To learn more about Multipool and its features, users can visit: Website Website Telegram Telegram X X CMC-Community CMC-Community About Multipool Multipool is a cutting-edge decentralized exchange (DEX) transforming the trading landscape for real-world assets (RWAs) and cryptocurrencies. Multipool is designed for fairness and equality, featuring a fully decentralized on-chain order book, deep liquidity through dynamic bracket pools, and seamless trading of RWAs and cryptocurrencies. Multipool Multipool Utilizing world-class innovations including industry-first FIX APIs, low latency networks, zero price impact auctions, trustless RFQs, peer-to-peer repo lending, and MEV bot protection, Multipool sets a new standard in DeFi trading. Experience unparalleled efficiency and security in your trading journey with Multipool – The DEX with CEX appeal. https://www.multipool.finance/ https://www.multipool.finance/ https://www.multipool.finance/ About Tokinvest Tokinvest is a pioneering marketplace that connects real-world asset issuers with investors globally. Our advanced platform simplifies the investment process by creating virtual tokens representing rights to assets and providing comprehensive lifecycle services from ideation to trading to asset servicing. Headquartered in Dubai, we leverage the region’s favourable regulatory environment to offer all investors access to the most desirable assets. Tokinvest Tokinvest https://tokinvest.capital/ https://tokinvest.capital/ https://tokinvest.capital/ Contact Public Relations Manager Angie Hermosa Multipool press@multipool.finance This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here. This story was distributed as a release by Chainwire under HackerNoon’s Business Blogging Program. Learn more about the program here . here here

Multipool Partners With Tokinvest To Deliver Next-Level Tokenized Real-World Asset Trading 

In this tutorial, I’ll show you how to deploy a full-stack JavaScript web app into Firebase. We’ll deploy a Next.js application to Firebase hosting. I’ll show you a quick and efficient process that can be completed in 5 minutes. https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true Creating the Next.js Project Let’s create a Next.js project if you don’t have one yet. Create a new Next.js project using the terminal with the npx command. npx create-next-app@latest Push the project to GitHub. This step is crucial as the project will be published directly on Firebase from GitHub.
Run the project locally using the "npm run dev" command to ensure everything works correctly. Setting Up Firebase Go to the Firebase console (https://console.firebase.google.com/) and click the "Add project" link.


Name the project e.g. "nextjs-on-firebase" and click a “Continue” button


In the next step, choose whether to enable Google Analytics. I’ll turn it off because I don’t need it for this tutorial.


After creating the project, navigate to the “App Hosting” section in the left sidebar. Click “Agree” to accept the Google Cloud Platform terms and conditions. The next step will be to upgrade the Firebase plan because hosting for full-stack applications is not free. Upgrading to Blaze Plan To continue, you must upgrade to the Blaze plan (pay-as-you-go). To upgrade the plan, click on the “Upgrade project” button. Fill in all the necessary details. If everything is okay, then you will see the screen below. After upgrading, click the "Get Started" button. At the next screen, you need to connect your GitHub account and project to Firebase. This is an essential step because we will use GitHub as a project source. Connect your GitHub account to Firebase.


Select your project from your GitHub repositories.


Choose the main branch (e.g., "master") for deployment.


Keep the automatic deployment toggle on for updates to Firebase when changes are pushed to the master branch.


Name the backend project (e.g., "njs-firebase") and click "Finish and deploy." If you get lost, you can watch this video: https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true Waiting for Deployment The deployment process takes about 2-5 minutes. During this time, Firebase creates the necessary cloud environment. You can view the progress on the dashboard, which also provides the URL for your future app. Accessing the Deployed App The provided URL may not work immediately. It can take another 3-5 minutes for the deployment to be fully complete. Once finished, a green check box appears in the "Rollout status" section. The Next.js project will be live on the Firebase platform. If you are having trouble accessing the project link, try clicking "App Hosting" in the left menu and opening the project link from there. If you want to know how to set up a custom domain for your project, please watch this video - “Firebase custom domain & Free SSL” That’s it! :) If you have any questions, please use the comments section below. Cheers! In this tutorial, I’ll show you how to deploy a full-stack JavaScript web app into Firebase. We’ll deploy a Next.js application to Firebase hosting. I’ll show you a quick and efficient process that can be completed in 5 minutes. https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true Creating the Next.js Project Let’s create a Next.js project if you don’t have one yet. Create a new Next.js project using the terminal with the npx command. Create a new Next.js project using the terminal with the npx command. npx create-next-app@latest npx create-next-app@latest Push the project to GitHub. This step is crucial as the project will be published directly on Firebase from GitHub. Run the project locally using the "npm run dev" command to ensure everything works correctly. Push the project to GitHub. This step is crucial as the project will be published directly on Firebase from GitHub. Run the project locally using the " npm run dev " command to ensure everything works correctly. npm run dev Setting Up Firebase Go to the Firebase console (https://console.firebase.google.com/) and click the "Add project" link. Name the project e.g. "nextjs-on-firebase" and click a “Continue” button In the next step, choose whether to enable Google Analytics. I’ll turn it off because I don’t need it for this tutorial. After creating the project, navigate to the “App Hosting” section in the left sidebar. Go to the Firebase console (https://console.firebase.google.com/) and click the "Add project" link. Go to the Firebase console ( https://console.firebase.google.com/ ) and click the "Add project" link. https://console.firebase.google.com/ Name the project e.g. "nextjs-on-firebase" and click a “Continue” button Name the project e.g. "nextjs-on-firebase" and click a “Continue” button In the next step, choose whether to enable Google Analytics. I’ll turn it off because I don’t need it for this tutorial. In the next step, choose whether to enable Google Analytics. I’ll turn it off because I don’t need it for this tutorial. After creating the project, navigate to the “App Hosting” section in the left sidebar. After creating the project, navigate to the “App Hosting” section in the left sidebar. Click “Agree” to accept the Google Cloud Platform terms and conditions. Click “Agree” to accept the Google Cloud Platform terms and conditions. The next step will be to upgrade the Firebase plan because hosting for full-stack applications is not free. Upgrading to Blaze Plan To continue, you must upgrade to the Blaze plan (pay-as-you-go). To upgrade the plan, click on the “Upgrade project” button. Fill in all the necessary details. If everything is okay, then you will see the screen below. After upgrading, click the " Get Started " button. Get Started At the next screen, you need to connect your GitHub account and project to Firebase. This is an essential step because we will use GitHub as a project source. Connect your GitHub account to Firebase. Select your project from your GitHub repositories. Choose the main branch (e.g., "master") for deployment. Keep the automatic deployment toggle on for updates to Firebase when changes are pushed to the master branch. Name the backend project (e.g., "njs-firebase") and click "Finish and deploy." Connect your GitHub account to Firebase. Connect your GitHub account to Firebase. Select your project from your GitHub repositories. Select your project from your GitHub repositories. Choose the main branch (e.g., "master") for deployment. Choose the main branch (e.g., "master") for deployment. Keep the automatic deployment toggle on for updates to Firebase when changes are pushed to the master branch. Keep the automatic deployment toggle on for updates to Firebase when changes are pushed to the master branch. Name the backend project (e.g., "njs-firebase") and click "Finish and deploy." Name the backend project (e.g., "njs-firebase") and click "Finish and deploy." If you get lost, you can watch this video: https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true https://youtu.be/-VwulR_wTv0?si=nW8dD2VCdhJPFSvg&t=82&embedable=true Waiting for Deployment The deployment process takes about 2-5 minutes. During this time, Firebase creates the necessary cloud environment. You can view the progress on the dashboard, which also provides the URL for your future app. Accessing the Deployed App The provided URL may not work immediately. It can take another 3-5 minutes for the deployment to be fully complete. Once finished, a green check box appears in the "Rollout status" section. The Next.js project will be live on the Firebase platform. If you are having trouble accessing the project link, try clicking " App Hosting " in the left menu and opening the project link from there. App Hosting If you want to know how to set up a custom domain for your project, please watch this video - “ Firebase custom domain & Free SSL ” Firebase custom domain & Free SSL That’s it! :) If you have any questions, please use the comments section below. Cheers!

Stories, News & Mentions about NNEXT

Nnext’s Stories on HackerNoon