Fotokite

fotokite

In this article, we are going to implement caching in a node js application using Redis, but, before we delve into the implementation details, let’s explore what caching is and how it can help the performance of our application. What is caching? Caching is the process of storing copies of files in a cache or a temporary storage location so that they can be accessed more quickly. - Cloudflare Now that we understand what caching is, let’s explore the reason for caching Why do we cache? Given many super fast services and options available for users on the Internet today, you don’t want your application to take too long to respond to users’ requests or you risk the chance of your users dumping your service for a competitor and keep your bounce-rate growing instead of your revenue. Below are a few of the reasons we cache: To save cost. Such as paying for bandwidth or even volume of data sent over the network. To reduce app response time. In general, caching done the right way will improve the performance of our application and lead to a win-win situation for us and our users. Prerequisites To follow through this tutorial you must have the following installed on your computer Node JS NPM Postman/Web Browser Code Editor (VsCode) If you don’t have Node.js installed just head on to the official website to get a copy of Node.js for your platform. Once you install node.js you will automatically have npm installed. Node.js Getting Started To get started, create a new directory for the application by running the following command on the terminal: cd desktop && mkdir node-caching && cd node-caching The commands above - navigate to the desktop directory cd desktop - create a new directory named “node-caching” mkdir node-caching - navigate into the newly created node-caching directoryInitialize the directory to create a package.json file by running cd node-caching npm init -y Install dependencies For this project we will be using Redis, axios and Express Framework for Node.js, so let’s install them by running the following: npm install express redis axios Open the newly created folder in your editor of choice. Your folder structure should now look like the one below: Create a simple Express server as shown below: express = ( ); app = express(); port = ;

app.listen(port, () => { .log( );
}); .exports = app; const require 'express' const const 3000 console `Server running on port ` ${port} module We are going to be making request to a public API for various food items recipe provided by http://www.recipepuppy.com In index.js file paste the following code: express = ( ); app = express(); port = ; axios = ( );
 
app.get( , (req, res) => { { fooditem = req.params.fooditem; recipe = axios.get( ); res.status( ).send({ : , : recipe.data.results
   });
  
 } (error) { .log(error)
 }
});
 
app.listen(port, () => { .log( );
}); .exports = app; const require 'express' const const 3000 const require 'axios' '/recipe/:fooditem' async try const const await `http://www.recipepuppy.com/api/?q= ` ${fooditem} return 200 error false data catch console console `Server running on port ` ${port} module Start the server by running node index.js and open postman to make a request to the recipe endpoint As we can see, the request completed in which is quite a long time to fetch data that doesn't change often. We will improve this by implementing caching using Redis. 615ms To be able to take full advantage of Redis offerings, we need to get Redis by compiling it directly from source. To do this kindly run the following command on your terminal: wget http: tar xvzf redis-stable.tar.gz
cd redis-stable
make //download.redis.io/redis-stable.tar.gz Confirm installation by running make test You can then copy redis to your path by running sudo make install To confirm that redis has been properly setup, start the redis server by running redis-server from your terminal. Then, open a new terminal tab/window and run redis-cli ping you should get back as response. For detailed setup instruction, visit the official guide on the website here PONG https://redis.io/topics/quickstart Now that we have correctly setup redis, the next thing is to use it in our application to improve it by reducing the turn around time of request and response. Add the following changes to index.js file express = ( ); axios = ( ); redis = ( ); app = express(); port = ; client = redis.createClient( );
 
client.on( , (error) => { .error(error);
});
 
app.get( , (req, res) => { { foodItem = req.params.fooditem; client.get(foodItem, (err, recipe) => { (recipe) { res.status( ).send({ : , : , : .parse(recipe)
       })
     } { recipe = axios.get( ); client.setex(foodItem, , .stringify(recipe.data.results)); res.status( ).send({ : , : , : recipe.data.results
         });
     }
   }) 
 } (error) { .log(error)
 }
});
 
app.listen(port, () => { .log( );
}); .exports = app; const require 'express' const require 'axios' const require 'redis' const const 3000 // make a connection to the local instance of redis const 6379 "error" console '/recipe/:fooditem' try const // Check the redis store for the data first async if return 200 error false message `Recipe for from the cache` ${foodItem} data JSON else // When the data is not found in the cache then we can make request to the server const await `http://www.recipepuppy.com/api/?q= ` ${foodItem} // save the record in the cache for subsequent request 1440 JSON // return the result to the client return 200 error false message `Recipe for from the server` ${foodItem} data catch console console `Server running on port ` ${port} module Explaining the cache process First we created a redis client and link it with the local redis instance using the default redis port (6379) client = redis.createClient( ); const 6379 Then, in the route handler, we tried to get the appropriate matching data to serve the request by checking for the key in our redis store. If found, the result is served to the requesting client from our cache and then we don’t have to make the server request anymore. /recipe client.get(foodItem, (err, recipe) => { (recipe) { res.status( ).send({ : , : , : .parse(recipe)
       })
     } // Check the redis store for the data first async if return 200 error false message `Recipe for from the cache` ${foodItem} data JSON But if the key is not found in our redis store, a request is made to the server and and once the response is available, we store the result using a unique key in the redis store: recipe = axios.get( ); client.setex(foodItem, , .stringify(recipe.data.results)); const await `http://www.recipepuppy.com/api/?q= ` ${foodItem} // save the record in the cache for subsequent request 1440 JSON Hence, subsequent requests to the same endpoint with the same parameter will always be fetched from the cache so long the cached data has not expired. The setex method of the redis client is used to set the key to hold a string value in the store for a particular number of seconds which in this case is 1440 (24 minutes). Full list of available redis commands and options can be found here: https://redis.io/commands Testing the application Now let’s test the application after implementing cache. Open postman and make a request to the same endpoint as before. Again, because the key is not found in the cache the request is sent to the server which takes 566 ms to complete. Since the key didn’t exist in the cache before, it is now saved in the cache and subsequent requests with the same data will be fetched from the cache which makes it faster, and also reduces the load on the server. Below is the response time after the cache: As we can see above, it took a blazing for the request to be completed because it was fetched from the cache. 3ms Now tell me, don’t you want to start caching already? Kindly note that this is just a tip of the iceberg of what we can do with redis and I recommend that you consult the official documentation to enjoy full capabilities of this amazing data store. https://redis.io/documentation Complete code can be found here https://github.com/iMichaelOwolabi/node-redis-caching-tut Previously published at https://dev.to/imichaelowolabi/caching-in-node-js-using-redis-o1b

How To Setup Caching in Node.js using Redis 

Given enough eyeballs, all bugs are shallow. ~ Linus’ Law Bugs! Bugs are aliens that creep into a programmer’s code at night when no one is watching and alter the state of a working code. These aliens have only one mission — to frustrate the life of a programmer. How does a programmer kill a bug before he dies of frustration? Yeah, you got it right! By debugging and removing the buggy code. But why would a programmer go into a debugging war without the right tools? If a programmer is going to debug he better do it the right way, using the right tools. If debugging is the process of removing software bugs, then programming must be the process of putting them in. ~ Edsger Dijkstra In smart contract development, like traditional centralized software , bugs creep into the smart contract developer’s code during the development lifecycle of the smart contract. While there are ‘Etherillion’ reasons why smart contracts could be buggy, one thing remains important, all bugs must be removed before the smart contract is deployed on the mainnet, or else, we risk losing funds and ultimately, the credibility of the smart contract. development There are several frameworks for developing smart contracts in solidity. In this article, the focus is on the Truffle Framework. . Smart contract bugs can be hard to find, and error messages can be very obscure. When building smart contracts using Truffle, the Truffle Debugger comes in very handy when it is time to debug a contract. This process of debugging can be tedious to reason about traditionally, and this is where the Truffle Debugger really helps — by allowing us to debug any transactions as long as we have the code and the artifacts of the transaction. Let’s talk briefly about the Truffle Debugger and then take an example to show how this tool can be used. Truffle aims to make a developer’s life easier by providing a development environment, testing framework, and debugging tools for smart contract development This is because when debugging a smart contract, you’re not running the code in real time; instead, you are stepping into the historical execution of that transaction on the blockchain, and mapping that execution onto its associated code. Debugging is a cyclic activity involving execution testing and code correction. Truffle Debugger Truffle Debugger is a command line tool integrated into the Truffle Framework which allows smart contract transactions to be debugged using the smart contract code and transaction artifacts. When the debugger is started, the command line interface provides a list of addresses transacted against or created during the course of the transactions, an initial entry point for the transaction and a list of available commands for using the debugger. Some of the debugger commands are highlighted below: : [o] step over This command evaluates the instructions evaluated by the virtual machine relative to the contract until the next line in the current smart contract file, skipping the functions referenced at the current execution point(if any). : [i] step into This command steps into the function called at the current execution point. : [u] step out This command will have the debugger step out of the current function, to the next line executed right after it. : [n] step next This command steps to the next logical statement or expression in the current function called. : [;] step instruction This command steps through each individual instruction evaluated by the virtual machine. You can check out other commands here Thus far, we have talked about debugging, and the Truffle Debugger, let’s have an example to really drive this home. Debugging a FoodCart smart contract The smart contract below models a simple food cart which allows anyone to add food items to the cart for sale and also allows anyone with enough ether to buy a food item off the cart. This contract is just for the purpose of illustration, and it should not be used in a production environment. Before we start this example, the following are required to follow this example without any issues: Truffle 4.0 or above Solidity compiler version 0.4.24 or above Private blockchain (Ganache CLI v6.1.6 or above) The repository for this article can be found , just in case you want to follow through the debugging process without coding the smart contract. here Step 1: Building the smart contract Let’s start by creating a directory for this project and building the smart contract. At the terminal enter in the following commands: mkdir FoodCart Enter into the folder and create a bare the truffle project. cd FoodCarttruffle init Navigate into the contracts folder and create a smart contract file FoodCart.sol cd contractstouch FoodCart.sol Open your FoodCart project in any IDE of your choice. I will be using Visual Studio code. Why? I really don’t know …lol. 😂. Open the contract and type in the smart contract below: FoodCart.sol Before we proceed any further, let me explain the smart contract above. The FoodCart smart contract can be sectioned into 6 parts: The state variables: The state variables, and store the address of the owner and the count of food items added to the FoodCart respectively. The mapping maps skus to food items. owner skuCount foodItems The enum: The enum is a user-defined data type that holds the state of the food items on the cart. The types listed in the enum are explicitly convertible to and from integers, i.e ( , ). State ForSale = 0 Sold = 1 The events: The events and log the details of the food items that are put on sale or sold. These events can be called by callbacks in javascript and their contents can be used to make using dApps more interactive. ForSale Sold The struct: The struct is a user-defined type which holds the properties of a food item. These properties can be accessed using a dot notation on the struct. FoodItem The function modifiers: The modifiers , , and are functions that automatically check a condition prior to executing the function on which they are applied to. The roles of the function modifiers used in this smart contract are obvious from their names. doesFoodItemExist isFoodItemForSale hasBuyerPaidEnough The functions: The functions , and adds food items to the contract, allows a food item to be bought and allows the details of food item to be viewed respectively. The constructor function initializes the state variable with the address that the contract is deployed on. The anonymous function allows ether to the sent to this contract. addFoodItem buyFoodItem fetchFoodItem owner payable Step 2: Deploying the smart contract Let’s deploy the smart contract on the private . network In your IDE, create a new file called in the folder. Open this file after creating it and add this code: 2_foodcart_migration.js migrations This piece of code will enable the framework to deploy our contract to the private blockchain. FoodCart.sol Open your terminal and navigate into the folder for this project and type this command: truffle develop This command starts a development blockchain with which we can start testing our contract. Running that command should produce this result: The image above shows that a development blockchain has been started on port 9545, test accounts have also been created for use, and the terminal is navigated to a new prompt . truffle(develop)> In the prompt, type the command to compile the contract. The result of the compilation is stored in the build folder of your project directory. truffle(develop)> compile truffle(develop)> compile Running the command should produce this result: compile Finally, let’s migrate the compiled contract to the blockchain for deployment. At the terminal, type the command to migrate the contract to the development blockchain that has been started for us. migrate truffle(develop)> migrate Running the command should produce this result: migrate Step 3: Interacting with the smart contract Let’s interact with our smart contract and get a feel of how it works. We will be adding food items to the food cart, checking the details of food items added to the cart, and also buy food items off the cart with Ether from one of the accounts created for us when we started the development blockchain. Still in the prompt, create a variable and store the instance of the deployed contract in it. truffle(develop)> foodCart truffle(develop)> let foodCart; truffle(develop)> FoodCart.deployed(). ((instance) => { foodCart = instance; }); then In the short code snippet above, we access the deployed contract via the web3 method which returns a promise interface and we pass a function which stores the instance of the deployed contract in the variable. With the instance of the contract stored in the variable, we can access the functions of the contract through the variable. FoodCart .deployed foodCart foodCart foodCart Let’s add some food items to the food cart by running the following code snippets at the prompt. First, let’s add a function that will help us add food items and print the result of the transaction at the console easily. truffle(develop)> The function allows us to easily add food items to the cart by passing the name and price of the food item to the function as arguments when it is called. The function acts as a wrapper for the in the smart contract by making the smart contract calls for us and formating the log output returned from the function call. We can add some food items with the function by running this commands: addFoodItemToCart addFoodItem addFoodItemToCart Now that we have about 3 food items on the the food cart, let’s buy some food items off the cart. Before we can buy a food item, we need to specify what address we will be using to make our purchase, because it is from this address that we can get the funds to buy food items. Recall that when we started our private blockchain, 10 test accounts were created for us and each of these accounts was credited with 100 ether which we can use to buy anything we want, we are rich 🤑🤑. Let’s create a variable to store one of these addresses or accounts so that we can easily call it anytime we want. in ether truffle(develop)> buyerAddress = web3.eth.accounts[1]; truffle(develop)> buyerAddress '0xf17f52151ebef6c7334fad080c5704d77216b732' const Since we have an account (yours will be different), we can add a function to buy food items off the food cart at our prompt. 0xf17f52151ebef6c7334fad080c5704d77216b732 truffle(develop)> The allows us to buy food items off the cart by calling the function with the and of the item. The amount to be paid for the item is taken from the account that was stored in our variable. Let’s buy Fried Rice off the food cart. From our previous transactions, we recall that the sku for Fried Rice is and it’s price is . So at the prompt, we call the function with these values: buyFoodItemFromCart itemSku amount buyerAddress 0 10 wei truffle(develop)> buyFoodItemFromCart From the output, we see that the state of the item is and the is now , indicating that this item is no longer for sale. Sold foodItemExist false Step 4: Debugging errors in the smart contract If you have made it thus far, you deserve a Noble prize for Tenacity 🎖, enjoy the fame it brings. So far, we have seen how the contract should behave. To be able to use the Truffle Debugger feature, we would introduce some errors while interacting with the contract and then use the debugger to debug the error and get it fixed. To debug a transaction, we need to have the hash of the transaction and then run command at the prompt followed by any of the debugger commands until we find out where the transaction failed. debug [transaction hash] truffle(develop)> We will try the following invalid transactions: Try to buy a food item that does not exist Try to pay an amount less than the price of a food item Before we start these transactions, we need to start the in another terminal, but still in the sample project. Open a new terminal, navigate to the FoodCart project and run this command . truffle develop logger truffle develop --log FoodCart $ truffle develop --log You should get this output: Connected to existing Truffle Develop session at http://127.0.0.1:9545/ The logger connects to an existing session at the port specified, listens for transaction events, and logs the output of the transaction which should include items like transaction hash, block number, etc. Let’s go ahead and make the life of our contract a living hell 👹. Invalid Transaction #1: Try to buy a food item that does not exist From our previous transaction where we added food items to cart, we had skus respectively for the 3 food items. We will try to use the sku to buy a food item that does not exist. 0, 1, 2 6 Trying to buy the item as shown in the command above produces the error which does not really tell us what or where the problem came from. Now, this can be a real headache when there’s no debugger. I have spent many hours trying to debug a smart contract without using the debugger and it can drain the last blood out of one. Let’s have a look at log output and see what we have there. UnhandledPromiseRejectionWarning: Error: VM Exception while processing transaction: revert ... The most important content of the log to us is the transaction hash , this will be different from what you have on your machine. With the transaction hash, we can debug the transaction and figure out where the problem is. Let’s debug this transaction. Copy the hash of the transaction from your debugger terminal and run this command: at the prompt. Your output should look like this: 0x90a2ef83e54426848523a4edcf0c9628045e03c69d95f989c5b3b557367c848c debug your-trasanction-hash truffle(develop)> From the image, we see that when the debug command is run, the debugger compiles the contracts, gathers transaction data, fetches the address that was affected and the contract that was deployed at that address, and shows a list of debugger commands that we can use to interact with the debugger. The most interactive command to use at the debugger is the command which steps through all the instructions executed during a transaction one at a time. The command is executed by pressing or , at the keyboard of course. step next step next enter n At the prompt, press enter continuously, following each instruction step until we reach the instruction where the transaction failed. There are steps before we reach the final instruction that halted our transaction - you will have to press enter 9 times to reach the halting instruction. Let’s look at the first 4 steps from this image below: debug(develop:0x90a2ef83...)> 8 From the image, we see that at line , the function was called, but before the execution of the function, the modifier at line was called to check if the food item to be bought exists in the cart. On further inspection, on line , we see that the modifier uses the function to ensure that the property of the food item with the sku given is . Let’s check what happened in the rest of the steps in the image below: 61 buyFoodItem doesFoodItemExist 64 33 require foodItemExist true At last step on line 33 in the image above, we see that the transaction halted because the transaction failed the required condition to be able to buy a food item from the cart. The item that we wanted to buy does not exist. The function throws a exception when a condition to which it is applied to fails. A exception reverts or undoes all changes made to the state in the current call (and all its sub-calls) and also flag an error to the caller. We have been able to successfully debug this code using the Truffle Debugger, and it has been pretty amazing. require state-reverting state-reverting Invalid Transaction #2: Try to pay an amount less than the price of a food item In this transaction, we will try to buy a food item with less amount than the price of the food item. In ‘step 3: Interacting with the smart contract’, we added 3 food items. Let’s try to buy ‘Chicken Pepper Soup’ with sku and price . At the prompt, call the function to buy a food item with less amount than the price. 1 10 wei truffle(develop)> buyFoodItem truffle(develop)> buyFoodItemFromCart(1, 5); truffle(develop)> (node:40269) UnhandledPromiseRejectionWarning: Error: VM Exception while processing transaction: revert Expectedly, this transaction fails, giving a cryptic error message as usual. To debug this transaction, we go to our log terminal and copy the hash of the transaction. On my machine the transaction hash is . With this transaction hash, we shall debug the transaction and figure out where the transaction halted. 0x5dc12d3ac524cfd1e3c0ea9265a155149ff16fcb18f904016a87e83cca5f9a30 truffle(develop)> debug 0x2ad4c056a678f221d761d0bc11f641f6b4e63b3016587acd8b16ccf5295bd4d3 Like we did in the first debugging process, we will use the debugger command to step through the transactions as it is very interactive and shows all the instructions that have been executed until we reach the instruction that halted the transaction. Use to step through the transaction history until you reach the instruction that halted the transaction as shown in the image below: step next enter In the image above, we see that at line 44, the modifier is called before the function is executed, and at line 45, the modifier requires that value sent by the buyer is greater than or equal to the price of the item. However, we know that we flouted this condition hence, it halted our transaction. So if we send the right amount, we will surely buy the food item we need. hasBuyerPaidEnough buyFoodItemFromCart Conclusion In conclusion, the importance of using a debugger while building smart contracts cannot be overemphasized. With a debugger, we can test our modifiers to ensure that our contract behaves appropriately, we can ensure that our contracts are secure by sending malicious transactions to our contract to see how it will behave and properly debug the transaction to see the instructions that have been executed up until the transaction halted, if it did. Most importantly, we can save our most valuable asset which is , by using a debugger whenever we face issues with our smart contracts, instead of fumbling around with our code. time References: Truffle Debugger Debugging and Testing IntelliJ IDEA Debug Tools Originally published at www.mayowatudonu.com .

Debugging Smart Contracts with Truffle Debugger: A Practical Approach

Source: Shutterstock Over the years, Chennai has grown to become the in India. SaaS hub But every time, when someone asked about the list of SaaS Companies in Chennai, there was no listing available. So here is a list of all the SaaS companies in Chennai in Alphabetical Order. Disclaimer: I work at Freshworks for Freshsales CRM but this list was put together with an intention to help the SaaS Community in Chennai. Opinions are my own and not the views of my employer. Animaker Animaker is a cloud-based video making app used by over 1.5 million users from 180+ countries. With Animaker in your arsenal, you can create explainer videos, social media videos, vertical videos & video infographics to meet growing demands of video in marketing, education & content space. , Founders: Srinivasa Raghavan Loganathan Kodiyarasu 2015 Founded in: Bootstrapped Funding raised: Nil Investors: ~60 Team Size: Chargebee Chargebee is a recurring billing platform for subscription based SaaS and E-commerce businesses. It allows you to automate payment collection, invoicing, email notifications and customer management, by integrating with leading payment gateways. , , Thiyagu, Founders: Krish Subramaniam Rajaraman Santhanam Saravanan KP 2011 Founded in: 24.2 Million USD Funding Raised: Accel Partners, Tiger Global, Insight Venture Partners Investors: 120+ Team Size: CloudCherry CloudCherry is an Experience Management platform that is disrupting the way organizations listen to the Voice of Customer. Through CloudCherry’s flexible, customizable, self-serve solution, businesses today can be present at every step of today’s complex customer journeys, and listen to customers through a variety of ways. Nagendra CL, Prem K Viswanath, Sriram Subramanian, Vijay Lakshmanan, Founders: Vinod Muthukrishnan 2014 Founded in: 7 Million USD Funding Raised: Cisco Investments, Vertex Ventures, IDG Ventures, Chennai Angels Investors: ~80 Team Size: CustomerLabs CustomerLabs is a digital marketing infrastructure platform to manage marketing operations. It lets businesses to track & sync the customer data across platforms without writing any code to various analytics, ads and marketing platforms. , Founders: Asim Ali Vishnu Vankayala 2013 Founded in: 50,000 USD Funding Raised: Times Internet Investors: <10 Team Size: Facilio IoT and ML-driven applications designed to unify your building performance in real-time. Facilio is an all-in-one app suite that unifies facilities and sustainability management across portfolio of large buildings. It helps bring people, machines and buildings come together to work in sync and create beautiful facilities experience — so that there are no more siloed data, teams lagging behind in maintenance or inefficient sustainability performance. , and Founders: Prabhu Ramachandran Rajavel Subramanian Yogendrababu Venkatapathy 2017 Founded in: 1.5 Million USD Funding Raised: Accel Partners Investors: ~24 Team Size: FourKites FourKites is the real-time supply chain visibility platform that Fortune 500 companies and 3PLs trust to track shipment location and temperature and proactively manage exceptions. Using a proprietary predictive algorithm to calculate shipment arrival times, FourKites enables customers to lower their operating costs, improve on-time performance, and strengthen their end-customer relationships. Founders: Mathew Elenjickal 2014 Founded in: 51.5 Million USD Funding Raised: HBS Angels Chicago, Hyde Park Angels, Hyde Park Venture Partners, Otter, Bain Capital Ventures, August Capital Investors: ~160 Team Size: Freshworks (previously Freshdesk) Freshworks creates solutions for support and sales, to engage with and delight both customers and employees. Freshdesk, a Cloud-based customer-support software firm, has been re-branded as Freshworks, which will be the parent company bringing together its suite of business software products — Freshdesk, Freshservice, Freshsales, Freshcaller, Freshchat, Freshmarketer and Freshteam. , Founders: Girish Mathrubootham Shan Krishnasamy 2010 Founded in: 149 Million USD Funding Raised: Accel Partners, Tiger Global Management, CapitalG, Sequoia Capital Investors: 1200+ Team Size: HappyFox HappyFox is a help desk ticketing system that is hosted on cloud, supporting multiple customer support channels like email, voice and live chat. HappyFox is a global help desk being rendered in 35 languages. With differentiation coming from its focus on user experience and simplicity, HappyFox is used by thousands of successful companies of all sizes. Founders: Shalin Jain 2011 Founded in: Bootstrapped Funding Raised: Nil Investors: ~20 Team Size: HippoVideo Hippo Video is a simple and quick video recording and sharing software for the busiest people. You can easily create, edit, store, share and track videos. The paid version lets you record for an unlimited period of time and can be exported to MP4 or stored/uploaded to Google Drive, YouTube, Vimeo and Google Classroom. Hippo Video, easily create or record videos for free at the start of a button. , , Founders: Karthi Mariappan S Nilamchand Jain Srinivasan Krishnan 2016 Founded in: Undisclosed Amount — Seed Round Funding Raised: Kae Capital Investors: <10 Team Size: Indix Indix has built a Products Platform that delivers product information and commerce-ready services for a fraction of the cost of alternatives. Indix combines AI with the largest collection of product data available: price, availability, and seller information, along with code-based identifiers and attributes. Businesses use the Indix Platform to improve the size and quality of their digital product catalog and develop innovative ways to buy and sell products. , , , Founders: Rajesh Muppalla Sanjay Parthasarathy Satya Kaliki Sridhar Venkatesh 2010 Founded in: 30.9 Million USD Funding Raised: Avalon Ventures, Anthemis Group, NGP Capital, Nexus Venture Partners Investors: ~70 Team Size: KiSSFLOW KiSSFLOW is a work automation platform designed for small and mid-sized businesses to automate their internal workflows and business processes. 2013 Founded in: Founders: Suresh Sambandam 1 Million USD Funding Raised: Undisclosed Investors: **Team Size: ~**150 Klenty Klenty is a Software Product that helps B2B Sales representatives to Prospect, Outreach, Follow-up at Scale and thereby achieve higher Sales Process Productivity & increase sales/meeting conversions with reduced manual efforts. Using Klenty, you can understand who is more interested in your product/services and get faster responses from the ideal prospects. You can create more sales closure meetings & opportunities thereby making your sales process smooth & efficient. , Founders: Praveen Kumar Vengat Krishnaraj 2015 Founded in: Nil Funding Raised: Nil Investors: ~20 Team Size: Octoze Octoze’s flagship product is a SaaS based platform to help schools, colleges and universities run more efficiently . It offers administrators, teaching staff, parents and students engage better with each other and drive better results for individuals and institutions. This combines learning management, ERP, reporting in one easy to use cloud based platform. , , Mouli Kumar Founders: Swaminathan Arunachalam Venkateshwara Rao 2014 Founded in: Bootstrapped Funding Raised: Nil Investors: ~40 Team Size: Paperflite Paperflite is a mobile-first sales enablement platform. It helps curate content from marketing and lines up the most appropriate assets in real-time to your sales teams, enabling them deliver the perfect pitch to your prospects. Paperflite is an all-new-yet-instantly-familiar way to share, track and organize all your content across every channel. Paperflite gives you better quality leads and empowers you to crush your targets using your existing content in a whole new way. 2016 Founded in: , , Founders: Vinoth Kumar Anant Bhat Yega Kumarappan 400,000 USD Funding Raised: Chennai Angels Investors: ~20 Team Size: Pipecandy PipeCandy uses data science techniques to discover the right prospects for B2B sales reps and helps them segment the prospects based on nuances specific to their respective industries. , and Founders: Ashwin Ramasamy Shrikanth Jagannathan Murali Vivekanandan 2016 Founded in: 1.1 Million USD Funding Raised: Indian Angel Network, IDG Ventures, Axilor Ventures and Emergent Ventures Investors: ~30 Team Size: Ramco Systems Ramco Systems is a cloud enterprise software company focused on providing multi-tenanted enterprise software to corporates in the area of HCM and Payroll, ERP and M&E MRO for Defence and Civil Aviation, with Mobile first philosophy and In-memory based Planning and Optimization engine. P R Venketrama Raja Founder: 1999 Founded in: 52 Million USD (Post-IPO Equity) Funding Raised: Axis Mutual Fund, Goldman Sachs, HDFC Holdings, Amansa Holdings, J O Hambro Capital Investors: ~3000 Team Size: ReferralYogi ReferralYogi is a SaaS based Customer Advocacy platform that promises sustainable revenue growth for businesses. It helps them identify their promoters, encourage referrals, manage references & create social buzz for their brands. Gandhi Gopinath, Sriram Venkatachalam Founders: 2017 Founded in: Nil Funding Raised: Nil Investors: <10 Team Size: Tagalys Create, curate & launch conversion optimized e-Commerce product listing pages with no engineering support Founded in: 2015 , Founders: Antony Kattukaran Palaniappan Chellappan Nil Funding Raised: Nil Investors: <10 Team Size: Unmetric Unmetric is a social media intelligence platform focused on brands. It is trusted by leading brands to understand their competitor’s efforts, uncover insights based on data and unlock new social strategies. Unmetric combines the power of people and technology to track and analyze the online behavior of over 30,000 brands segmented across 30 sectors for all major social channels. , , Founders: Joe Varghese Kumar Krishnasami Lakshmanan (Lux) Narayan 2011 Founded in: 8.7 Million USD Funding Raised: Nexus Venture Partners, JAFCO Asia Investors: : ~85 Team Size Xobin Xobin’s suite of recruitment softwares cuts down 70% of your recruitment cost and helps you double up the quality of hires. Source,assess and onboard talent into the your team with Xobin’s intelligent recruitment software solutions. , Founders: Amrit Acharya Guruprakash Sivabalan 2016 Founded in: Undisclosed Amount (Seed Round) Funding Raised: Axilor Ventures Investors: : 11 Team Size Zoho Zoho offers a suite of business, collaboration, and productivity applications. The company offers over 30 online applications from CRM to mail, office suite, project management, invoicing, email marketing, social media management, and more. The suite comprises Zoho Writer, Zoho CRM, Zoho Sheet, Zoho Show, Zoho Projects, Zoho Meeting, Zoho Creator, Zoho Docs, Zoho Invoice, Zoho People, Zoho Mail, Zoho Assist, Zoho Reports, Zoho Recruit, Zoho Support, Zoho Books, Zoho Bug Tracker, Zoho Campaigns, Zoho Sites, Zoho Connect, and more. 1996 Founded in: Sridhar Vembu and Tony G. Thomas Founders: Bootstrapped Funding Raised: Nil Investors: 5500+ Team Size: Connect with me on Linkedin Disclaimer: I work at Freshworks for Freshsales CRM but this list was put together with an intention to help the SaaS Chennai Community. Opinions are my own and not the views of my employer. If I have missed out any of the SaaS companies in Chennai or if you would like to modify any information for any company, drop in a comment and will do the necessary update.

List of SaaS Companies in Chennai

Who would’ve thought developing in a Portal would be so bearable. Whilst serverless is in no way a new , it is only recently whilst studying for my that I have truly come to enjoy the power of products such as AWS Lambda and Azure Functions. Whether it be for scalability, costs or ease of implementation; there is merit in taking the serverless approach with your cloud based solutions. This piece is not necessarily a fleshed out tutorial of how to work with Microsoft’s Azure Functions but more of an exploratory piece on just how easy it is to create a database backend of sorts all from within the Azure Portal itself! technology 532 Microsoft Exam “API” Note that I don’t necessarily advocate that this is the way you should develop Azure Functions. Microsoft supports using Git and other version control systems for working with Azure functions, as well as providing an Azure Functions CLI for running functions locally. Setting Up Assuming you have an Azure Subscription ( ), locate the resource in the marketplace. Whilst usually I’d recommend you create your resource group and storage account seperately, for the purposes of a concise process we’ll create both with the function. if not sign up here it’s free “Serverless Function App” For those who are unsure about the Azure jargon, a is essentially what the name implies and is a collection of Azure resources which are the services you use on Azure. A is a type of resource which provides multiple types of storage solutions all under the one resource including file, blob, table, queue and more. We’ll be focusing on using for this tutorial which Azure describes as ; Resource Group Storage Account Tables NoSQL storage for unstructured and semi-structured data — ideal for web applications, address books, and other user data. When creating your function app, Azure will pre-fill the names for the resource group and storage account as you type. For the hosting plan I’ve gone with Consumption as that is the type in which you are billed for usage rather than uptime. Location is very much dependent on, well, your location so it doesn’t really make a different to the function itself. Clicking create will validate the Azure Function configuration and add it to your Function Apps. Let’s Write Up Some Functions! Once the Function App is deployed you can find it in the aptly named section of the Azure Portal. Before we get into creating the functions I like to modify my CORS origins to allow all (*) as for the purposes of this article defining the specific origins I’m using is unnecessary. “Function Apps” Click on your function app and go to Platform Features -> CORS and then remove all the allowed origins, add a single origin of *. Once those changes are saved, go to the Functions section of your Function App and click the new function button. This will display all the templates Azure has to offer. For this tutorial we’ll be using the HTTP GET and HTTP POST templates as the template includes everything we need to connect to our Table Storage. So many options :O We’ll start with HTTP GET, for this tutorial I’ll be using C# but as I’m admittedly relying on generated code for the most part you’re more than welcome to use any language you wish. Let’s go with a food theme for a change. For this tutorial we’ll be adding and retrieving items from a food database. For the most part it is up to you what you name your function, what will need to be changed is the table name and storage account connection. The table name can be anything as Azure will create a table if it doesn’t exist already, and to retrieve your storage account that you created previously click the button and select it from the list of options. Repeat this process for HTTP POST. “new” First we’ll edit our GET function to make it a little bit more our own. Opening the function in the Azure Portal will open up a with our function in it. If you are using a strongly typed language like C# for your function, Azure will have generated you a for the function (by default its person). Let’s edit this a bit to be more unique… monaco editor TableEntity As you can see a TableEntity is very much a Plain Old C# Object with the exception of the and . Whilst this is very much not an Azure Functions concept and more of an Azure Tables piece of info, to sum it up a can be thought of as a Primary Key in the table. We can use it to uniquely identify and easily retrieve an entry in our table. The is a bit more complex and defines how Azure will distribute the entry in your storage. It can be assumed that elements with the same partition key are kept in the same partition of your storage and so can easily be queried and batched together. RowKey PartitionKey RowKey PartitionKey As you can probably guess, for this example I will be using the name of the as a , with all items partitioned the same. FoodItem RowKey I also need to refactor the function for the so that it works with the correct data types. HttpResponseMessage With those changes our GET endpoint is done! All of the implementation achieved within the Azure Portal editor. For testing the function we can copy URL from the button in the top right hand corner and query with Postman, the response an expected empty array. Get Function URL Your navigate over to your POST function, for mine I wrote the following code; Whilst the model remains unchanged, there are some things to note in the function itself. Emphasis on nullable data types, especially for example. int? My validation is pretty much ensure that and are present. name rating There is no need to explicitly set a and a like in the originally generated code as we take care of that in the constructor and the setter. PartitionKey RowKey Name Once implemented, save your post function and ensure there are no errors in your log. If all is good congratulations! You just implemented GET and POST endpoints utilising Azure Functions backed by Azure Table storage. To test it let’s open up postman and send some data to the POST endpoint; Nothing was more satisfying than the 201 I received for this GET Endpoint works as expected. Whilst there’s so much more to explore with Functions, I’m hoping this was a good primer into just how easy it is to get started with them. Azure If you enjoyed this article please give us a clap as it inflates my ego and fuels my need to write more pieces. PS: Just wanted to recommend Scott Duffy’s Udemy Course “70-532 Developing Microsoft Azure Solutions Certification” for being the reason for me wanting to write this article. Definitely worth checking out as it’s incredibly in-depth, up to date and modelled around the Microsoft Examination of the same name.

A Simple, Serverless API using Azure Tables & Functions

I’ve been writing Ruby code for years, and like me, you may reach out for familiar tools like Redis or Sidekiq to process background jobs and data. I’d like to show you why sometimes, pure Elixir is more than enough to get the job done. This is the story of how I replaced Redis/Exq with pure Elixir and the Erlang :queue class. A huge thank you to for his videos on GenServer. If you’re having trouble understanding GenServer, this will be a tremendous help. omgneering I built as a learning exercise to really understand Elixir and see what it takes to ship production ready code. And while the version on Github right now works, it’s lacking in very important areas I set out in the initial goals. Magnetissimo Goals: Crawl multiple index sites for torrents and magnet links. — Working! Run without ceremony. No pointless configuration needed. — Eh… kinda? High performance, leveraging Elixir’s GenServer and Erlang’s BEAM VM. — Working! Unit tested for correctness. — Working! It wasn’t easy for people to run the project, even developers had questions and I wanted zero-friction. The less steps there are in running the higher the adoption rate would be. Magnetissimo I found my solution in Erlang’s queue class, and in Elixir’s GenServer. This was step one towards that ultimate goal. The first thing I did was make Crawlers, and create a worker for each ofthose crawlers. All supervised by my supervisor. children = [ Start the Ecto repository supervisor(Magnetissimo.Repo, []), Start the endpoint when the application starts supervisor(Magnetissimo.Endpoint, []),worker(Magnetissimo.Crawler.ThePirateBay, []),worker(Magnetissimo.Crawler.EZTV, []),worker(Magnetissimo.Crawler.LimeTorrents, []),worker(Magnetissimo.Crawler.Leetx, []),worker(Magnetissimo.Crawler.Demonoid, []),] Each crawler is actually a GenServer implementation. For example, here’s ThePirateBay version of the crawler. defmodule Magnetissimo.Crawler.ThePirateBay douse GenServeralias Magnetissimo.Torrentalias Magnetissimo.Crawler.Helper def start_link doqueue = initial_queueGenServer.start_link(__MODULE__, queue)end def init(queue) doschedule_work(){:ok, queue}end defp schedule_work doProcess.send_after(self(), :work, 1 * 1 * 300) # 5 secondsend Callbacks def handle_info(:work, queue) docase :queue.out(queue) do{{_value, item}, queue_2} ->queue = queue_2queue = process(item, queue)_ ->IO.puts "Queue is empty - restarting queue."queue = initial_queueendschedule_work(){:noreply, queue}end def process({:page_link, url}, queue) doIO.puts "Downloading page: #{url}"html_body = Helper.download(url)if html_body != nil dotorrents = torrent_links(html_body)queue = Enum.reduce(torrents, queue, fn torrent, queue ->:queue.in({:torrent_link, torrent}, queue)end)endqueueend def process({:torrent_link, url}, queue) doIO.puts "Downloading torrent: #{url}"html_body = Helper.download(url)if html_body != nil dotorrent_struct = torrent_information(html_body)Torrent.save_torrent(torrent_struct)endqueueend Parser functions def initial_queue dourls = for i <- 1..6, j <- 1..50 do{:page_link, "https://thepiratebay.org/browse/#{i}00/#{j}/3"}end:queue.from_list(urls)end def torrent_links(html_body) dohtml_body|> Floki.find(".detName a")|> Floki.attribute("href")|> Enum.map(fn(url) -> "https://thepiratebay.org" <> url end)end def torrent_information(html_body) doname = html_body|> Floki.find("#title")|> Floki.text|> String.trim|> HtmlEntities.decode magnet = html\_body  
  |> Floki.find(".download a")  
  |> Floki.attribute("href")  
  |> Enum.filter(fn(url) -> String.starts\_with?(url, "magnet:") end)  
  |> Enum.at(0)  

size = html\_body  
  |> Floki.find("#detailsframe #details .col1 dd")  
  |> Enum.at(2)  
  |> Floki.text  
  |> String.split(<<194, 160>>)  
  |> Enum.at(2)  
  |> String.replace("(", "")  

{seeders, \_} = html\_body  
  |> Floki.find("#detailsframe #details .col2 dd")  
  |> Enum.at(2)  
  |> Floki.text  
  |> Integer.parse  

{leechers, \_} = html\_body  
  |> Floki.find("#detailsframe #details .col2 dd")  
  |> Enum.at(3)  
  |> Floki.text  
  |> Integer.parse  

%{  
  name: name,  
  magnet: magnet,  
  size: size,  
  website\_source: "thepiratebay",  
  seeders: seeders,  
  leechers: leechers  
} endend Initial_queue is a function that creates an Erlang :queue object with the initial urls that sprawl out and link to other pagination pages or individual torrent links. Each element in my :queue is a tuple, with two parts: {:torrent_link, “some_url”}{:page_link, "some_url"} Using function pattern matching in the process methods above, I can easily either parse a pagination link or parse an individual torrent page. The schedule_work function then schedules the next item to be processed. The end result is more cohesive code, with less indirection. It’s much easier now to add a new crawler to the project. It’s also easier to know what exactly is running. Less chances for bugs, and more predictable growth behavior. One downside with this approach is volatility. If my app shuts down, I will lose the queue to process. But I’m comfortable with that for this particular project. One potential upgrade will be to change from handle_info, to an async handle_call. My next step is going to be using to build a single deployable executable so end users can just run it and have start service on localhost. Distillery Magnetissimo

Stories, News & Mentions about FOTOKITE

Fotokite’s Stories on HackerNoon