MobileServe is a fast growing B2B SaaS company that is disrupting the $1

MobileServe

mobileserve

There has been a high tide wave in the increment of fantasy sports app lovers all over the world. can be seen as a perfect partner for a sports lover who wants to get involved in the sports in any which way. Fantasy sports app So, what exactly is a fantasy sports app? Fantasy sports should be described as more of an online game under which participants assemble virtual or more of an imaginary team of the professional players that are actually playing in sports match at that time or around that time. The teams created by the users perform on the basis of actual performance given by the selected players in the virtual team. These performances are converted to points that are totalled on the basis of points roster designed by each and every specific fantasy team’s creator. This point system is not that tough to be understood in the manual form by the person who looks after the league and coordinates it overall. Points of a particular match can also be calculated using computer systems that keep an eye on actual up and down of a professional match. In a specific fantasy sports, team owners trade, draft and select players in the real sports. How is Fantasy Sports Market growing significantly? Fantasy sports app might have started as a fun activity among a group of friends but its sparkling popularity has made it an overnight success all across the globe. This year around 56.8 million people in the U.S. and Canada will be playing fantasy sports, according to the Fantasy Sports Trade Association. This is said to be a 37% increase from a year ago after increasing just 16% over the previous three years combined. As far as actual expenditures are concerned, the Fantasy Sports Trade Association estimated that 32 million Americans spend $467 per person or about $15 billion in total playing. Around 11 billion was said to flow toward football. Ad revenues associated with fantasy hosting sites are not counted in the above figure. It can be said that there would be only a few numbers of traditional players that play fantasy sports on a daily basis. Fantasy sports is said to be around €23 billion industry in the United States with around 57 million fantasy sports players in the US and Canada. But Eilers Research shows that every day the game will produce around €2.3 billion in entry fees this year and carry on growing 41% annually and in that way reaching a mammoth €12.8 billion in 2020. Fantasy Sports on a rise in Indian subcontinent With India being an economy on the upward rise, fantasy sports on kabbadi, cricket and football are said to have gained more than expected pace with the help of ever-growing technology. So with this, it can be stated that India is growing with each passing day and in coming days, With around 500 million expected users of the internet in 2017 out of which 400 million accessing internet via mobile phones, India is a market of opportunity for fantasy sports operators. There are said to be around 7 million players in india that plays fantasy sports on a regular basis. These numbers include a variety of sports like hockey, kabbadi, cricket along with football. Regarding percentage, the growth rate can be estimated at around 30–50% per year. Numbers concerned with it predict that the country can easily predict itself to reach the figure of around 50 million enthusiasts in the coming three years. With all the factors combined that include growth of technology, availability of high quality, better functioning android and iOS phones, fantasy sports market is going to grow at a rapid rate, make no doubt about it and with such stats, it can be said that it’s only going to create a pool of opportunities in different sections of fantasy sports and sports companies around the world are working continuously to dedicated to different sports and demography. develop fantasy sports mobile application Learn How to develop a Fantasy Sports Mobile Application Top Fantasy Sports App Developers let’s find about the top app developers in the arena of fantasy sports. Octal IT solution :- This leading software development company was established in the year 2007. Since then, they have developed over 1,100 mobile and web apps for over 700 clients from all across the globe. With a well-gelled team of more than 150 seasoned professionals, they provide clients with the best innovative solutions from their well-established development centres and also through onsite work environments. With high quality and affordable solutions, this company has earned themselves notable associations in the form of technology leaders like NASSCOM, Microsoft, Amazon Web Services, STPI, Acquia, D&B and many others. They are also praised and taken a note of by hundreds of clients on Clutch, GoodFirms, AppFutura, AppLancer, Appdexa and Extract, being among Top 10 Mobile App Developers on these platforms on a consistent basis. They are a renowned name in fantasy sports world as they are related to , fantasy sports software, fantasy games website development, daily fantasy sports web development, fantasy football development and many more related areas. Fantasy sports mobile application Arkasoftwares.com :- Arkasoftware is one of the leading names when it comes to fantasy sports mobile app and software development solutions. Founded in 2010 and with an experienced team of 100+ seasoned professional, the company has been continuously working in multiple technologies and catered more than 400 clients across the globe. Arka Softwares provides high quality and cost-effective mobile app solutions. With a well-gelled team of experienced developers and designers, they have earned a renowned name in the arena. The company is well admired by various prestigious research firms such as Clutch, Extract, Goodfirms, Appdexa, Skilled and Appfutura. fantasy sports app development Their seasoned subject experts and developers are well versed about the fantasy sports domain. Arka Softwares is one-stop solutions for your entire fantasy sports app & mobile app related requirement, Right from customized fantasy mobile apps to integrating cryptocurrency in the fantasy app, they have covered everything that a fantasy app required. Mobiwebtech.com Mobiwebtech.com Mobiweb technologies is another professional and one of the most trustworthy fantasy sports website development company that is known for providing fully customized, vigorous, responsive, remarkable, intense fantasy sports software and fantasy sports development arsenal. They have a team of highly-skilled and experienced professionals who can develop any kind of sports related websites and because of such great expertise they know what it goes into to build a high functioning sports website. As there is a new wave in the market of fantasy sports there is quite a healthy competition which in turns asks you to be better with each passing day and keeping this in mind, they are always working in their new skills and methods that will put them a step ahead of their competitors. Visvero.com :- Visvero is one of the most professional fantasy sports website development company that gives almost all types of fantasy sports solutions to all of their clients present across the globe. They have a well-gelled team of developers that has quite an experience in giving ideas and solutions in the app development arena for multiple games and sports. They are known for giving customized, responsive, robust and quite remarkable fantasy sports apps and websites. They have delivered quite a few fantasy sports apps and websites so they are quite aware of the process and efforts that go into it. They are a reliable app development company that works on three related aspects of a successful website development and that are a deadline, quality and discipline. Today there is a lot of competition in the fantasy sports market so in order to stay in the competition they rely on these aspects. SportsInteractive.net :- Mumbai-based Sportz Interactive has been driving the sports business forward. Founded in 2002, the company offers products like fantasy gaming, sports mobile app and services like live score, news, statistic, and players record data. They have also started providing users engagement features with the launch of analytics and other broadcast solutions.  The company has the record database for all major sports like Cricket, football, Formula One, Moto GP, Olympic Games which other sports organization may not have. Additionally, the clients of the Sportz Interactive include Star Sports, Yahoo, NDTV, ESPNcricinfo, Pro Kabaddi, Delhi Daredevils, Wisden India, Sony Six, Web18, Indian Super League, Fairfax Media, and International Cricket Council etc. sports-focused solutions company Vinfotech.com :- They are the latest type of product development organization which came out a creative idea of design thinking and have their eye on great level of user engagement. They know what is required to build a successful digital experience in the ever increasing noisy world, providing solutions that customers stick to and keep coming back. They are setting a trend by creating, out of box fantasy sports solutions in sectors other than sports, on a consistent basis. Their is one of a kind and has helped quite a few brands in industries that of politics, movies, music, stocks. They build fascinating apps for their clients’ sales team or their employees, for teenagers and senior citizens, for an amateur community or a particular group of experts. fantasy sports app development Codiant.com :- This company was established in 2010 and headquartered in the US. They have all the necessary solutions for your development needs. They build everything ranging from custom web application development and mobile apps to smooth website development along with e-commerce web development. To deliver the top of the world user experience is one of their basic strengths. They have a team full of experts that develops fantasy sports software solutions that contain a long list of sports and games such as Cricket, Football, Basketball, Hockey, Soccer, Baseball, Rugby and many others. Their expertise lies in fantasy sports app development, sports league website development, every day and season-long fantasy sports web development, sports betting software development, white label fantasy sports software development, fantasy football website and mobile app development. Krify.com Krify is a trustworthy and reliable fantasy sports app and website development company that provides to its clients exactly what they are thinking of. They have a modern development technique that allows them to nurture and create custom responsive Web Design that goes compatible with desktop, mobile and tablet. Their team of experts is always on the toes to serve to the demands of clients who are in search of their responsive sites to be developed. Let’s Nurture : Let’sNurture can be deemed as a global leader in the field of providing fantasy sports website design and mobile app development services across the globe. They have a highly skilled team that develops and design a fantasy sports app for leagues, teams, and the fantasy sports sector. Their innovative features can be integrated into fantasy sports app development. They are a renowned block-chain app development company and they help to build up a dispread platform in order to look after transactions for one’s fantasy sports business model. Dreamco Design : Dream co design is a highly professional sports app design company which can be trusted. They have been providing top notch mobile solutions for over a decade now. They work with data providers, teams, leagues, fantasy sports operators, athletes and more. Every mobile device to develop is custom and supported on both android and iOS mobile phones. They also design, develop and integrate sports data feeds for most of the big named companies. Blueyellow Media : They can create, design and run a cost-effective fantasy game for a sporting association, sporting event or sporting brand. They collaborate with companies and brands in order to build branded fantasy sports websites for events that of Football World Cup, the Lions Rugby Union tour and Rugby World Cup. They on your order build you a fully customized, mobile optimised, fully hosted website with a proper overall look to lighten up your brand. They build games for quite a number of sports that includes cricket, football, rugby, basketball, handball, and lacrosse. Algoworks Algoworks is an IT service provider company that also takes pride in developing sports websites and apps and is recognized across the globe as technology experts with roots in Sunnyvale, Noida and California. They provide services in important areas of enterprise content management solutions (CMS), enterprise mobile app development, customer relationship management (CRM) and software product engineering (SPE). So this was the list of top s that will help you out with your exact requirements. If you planning to enter into the world of ever growing fantasy then go have a detailed look at the outlook of these giants and go with the one that matches your level of appetite. fantasy sports app and software development companie

Top 10 Fantasy Sports App Development Companies

A Look at the Trends in Developer Jobs: A Meta Analysis of Stack Overflow Surveys

Una mirada a las tendencias en los trabajos de desarrollador: un metaanálisis de las encuestas de desbordamiento de pila

Un regard sur les tendances des emplois de développeur : une méta-analyse des enquêtes sur les débordements de pile

डेवलपर नौकरियों में रुझानों पर एक नज़र: स्टैक ओवरफ़्लो सर्वेक्षणों का एक मेटा विश्लेषण

開発者の仕事の傾向を見る: スタック オーバーフロー調査のメタ分析

Uma olhada nas tendências em trabalhos de desenvolvedor: uma meta-análise de pesquisas de estouro de pilha

Xem xét xu hướng công việc của nhà phát triển: Phân tích tổng thể về Khảo sát tràn ngăn xếp

看看开发人员工作的趋势：堆栈溢出调查的元分析

In the previous , I discussed whether it is possible to use machine learning (in particular, face and mask detection) in the browser, approaches to detection, and optimization of all processes. article Today I want to give the technical details of the implementation. Technologies The primary language for development is TypeScript. The client application is written in React.js. The application uses several neural networks to detect different events: face detection, mask detection. Each model/network runs in a separate thread (Web Worker). Neural networks are launched using TensorFlow.js, and Web Assembly or WebGL is used as a backend, which allows you to execute code at speed close to native. The choice of this or that backend depends on the size of the model (small models work faster on WebAssembly), but you should always test and choose what is faster for a particular model. Receiving and displaying a video stream using WebRTC. The OpenCV.js library is used to work with images. The following approach was implemented: The main thread is only orchestrating all processes. It doesn't load the heavy OpenCV library and doesn't use TensorFlow.js. It gets images from the video stream and sends them for processing by web workers. A new image is not sent to the worker until it informs the main thread that the worker is free and can process the next image. Thus a queue is not created, and we process the last image each time. Initially, the image is sent for face recognition, in case the face is recognized; only then is the image sent for mask recognition. Each result of the worker is saved and can be displayed on the UI. Performance Receiving an image from a stream - 31 ms Face detection preprocessing - 0-1 ms Face detection - 51 ms Face detection post-processing  - 8 ms Mask detection preprocessing - 2 ms Mask detection - 11 ms Mask detection post-processing - 0-1 ms Total: Face detection - + = 60 ms 31 ms 91 ms Mask detection - 14 ms In ~ 105 ms, we would know all the information from the image. Face detection preprocessing is getting an image from a stream and sending it to a web worker. Face detection post-processing - saving the result from the face detection worker and drawing it on the canvas. Mask detection preprocessing - preparing a canvas with an aligned face image and transferring it to the web worker. Mask detection post-processing - saving the results of mask detection. Each model (face detection and mask detection) runs in a separate web worker, which loads the necessary libraries (OpenCV.js, Tensorflow.js, models). We have 3 web workers: Face detection Mask detection Worker-helper that can transform images uses heavy methods from OpenCV and TensorFlow.js. For example, to build a calibration matrix for multiple cameras. Features and tricks that helped us in development and optimization Web workers and how to work with them A web worker is a way to run a script on a separate thread. They allow running heavy processes in parallel with the main thread without blocking the UI. The main thread executes the orchestration logic; all heavy computation is running in the web workers. Web workers are supported in almost all browsers. Features and limitations of web workers Features: Access only to a subset of JavaScript features Access to object navigator Read-only access to the object location Possibility to use XMLHttpRequest Possibility to use setTimeout() / clearTimeout() и setInterval() / clearInterval() Application Cache Importing external scripts using importScripts() Creating other web workers Limitations: No access to DOM No access to windows No access to the document No access to parent To provide communication between the main thread and the web workers and the event handler is used. postMessage onmessage If you look at the specification of the method, you will notice that it accepts not only data but also a second argument - a transferable object. postMessage() worker.postMessage(message, [transfer]); Let's see how using it will help us. A transferable interface is an object that can be passed between different execution contexts, such as the main thread and web workers. This interface is implemented in: ImageBitmap OffscreenCanvas ArrayBuffer MessagePort If we want to transfer 500 MB of data to the worker, we can do it without the second argument, but the difference will be in the time transfer and memory usage. Sending data without an argument will take 149 ms and 1042 MB for Google Chrome, in other browsers even more. When you use the transfer argument, it will take 1ms and will decrease memory consumption by 2 times! Since images are often transferred from the main thread to the web workers, it is important for us to do this as quickly and efficiently as possible for memory usage, and this feature helps us a lot with this. Using OffscreenCanvas The web worker does not have access to the DOM, so you cannot use canvas directly. comes to the rescue. OffscreenCanvas Advantages: Fully detached from the DOM It can be used both in the main thread and in web workers It has a transferable interface and does not load the main thread if rendering running in a web worker Advantages of using requestAnimationFrame allows you to receive images from the stream with maximum performance (60 FPS), and it is only limited by the camera's capability, not all cameras send video with such frequency. requestAnimationFrame The main advantages are: Browser optimizes requestAnimationFrame calls with other animations and drawings. Less power consumption, it's very important for mobile devices It works without a call stack and doesn’t create a call queue. Minimum call frequency 16.67 ms (1000 ms / 60 fps = 16.67 ms) Call frequency can be controlled manually Metrics of application At first, using stats.js seemed to be a good idea for displaying application metrics, but after the count of metrics became 20+, the main flow of the application began to slow down due to the specifics of the browser. Each metric uses a canvas on which draws a graph (data are received very often there), and the browser calls re-render with high frequency, which negatively affects the application. As a result, the metrics are underestimated. To avoid such a problem, it is better to abandon the use of "beauty" and simplify displaying the current and calculated average for the entire time by text. Updating a value in the DOM will be much faster than rendering graphics. Memory leaks control Quite often, during development, we encountered memory leaks on mobile devices, while on a desktop, it could work for a very long time. In web workers, it is impossible to know how much memory it actually consumes ( does not work in web workers). performance.memory Based on this, we provided for the launch of our application through web workers and completely in the main thread. By running all our detection models on the main thread, we can take the memory consumption metrics and see where the memory leak is and fix it. The main code of models in web workers We got acquainted with the main tricks that were used in the application; now we will look at the implementation. For working with web workers initially, was used. It's a very handy library that allows you to work with the worker as a class object without using the and methods and control the asynchronous code using async-await. All this was convenient until the application was launched on a tablet (Samsung Galaxy Tab S7), and suddenly it crashed after 2 minutes. comlink-loader onmessage postMessage After analyzing all the code, no memory leaks were found, except for a black box of this library for working with workers. For some reason, the launched Tensorflow.js models were not cleared and stored somewhere inside this library. It was decided to use a , which allows you to work with web workers from pure js without unnecessary layers. And this solved the problem; the application works for days without crashes. worker-loader Face detection worker Create web worker .faceDetectionWorker = workers.FaceRgbDetectionWorkerFactory.createWebWorker(); this Create a message handler from a worker in the main thread .faceDetectionWorker.onmessage = (event) => { (event.data.type === ) { .faceDetectionWorker.postMessage({ : ,
     backend,
     streamSettings,
     faceDetectionSettings, : .imageRatio,
   });
 } (event.data.type === ) { .isFaceWorkerInit = event.data.status; ( .isFaceWorkerInit && .isMaskWorkerInit) { .grabFrame();
   }
 } (event.data.type === ) { .onFaceDetected(event);
 } { ( );
 }
}; this async if 'load' this type 'init' imageRatio this else if 'init' this // When both workers inited it is run processes to grab and process frames only if this this await this else if 'faceResults' this else throw new Error `Type= is not supported by RgbVideo for FaceRgbDatectionWorker` ${event.data.type} Sending an image for face processing .faceDetectionWorker.postMessage(
 { : , : .lastImage, : lastItem!.index,
 },
 [ .lastImage], ); this type 'detectFace' originalImageToProcess this lastIndex this // transferable object Face detection web worker code The init method initializes all the models, libraries, and canvas that are needed to work with. init = (data) => { { backend, streamSettings, faceDetectionSettings, imageRatio } = data;

 flipHorizontal = streamSettings.flipHorizontal;
 faceMinWidth = faceDetectionSettings.faceMinWidth;
 faceMinWidthConversionFactor = faceDetectionSettings.faceMinWidthConversionFactor;
 predictionIOU = faceDetectionSettings.predictionIOU;
 recommendedLocation = faceDetectionSettings.useRecommendedLocation ? faceDetectionSettings.recommendedLocation : ;
 detectedFaceThumbnailSize = faceDetectionSettings.detectedFaceThumbnailSize;
 srcImageRatio = imageRatio; tfc.setBackend(backend); tfc.ready(); [blazeModel] = .all([
   blazeface.load({ maxFaces: faceDetectionSettings.maxFaces, inputWidth: faceDetectionSettings.faceDetectionImageMinWidth, inputHeight: faceDetectionSettings.faceDetectionImageMinHeight, iouThreshold: faceDetectionSettings.iouThreshold, scoreThreshold: faceDetectionSettings.scoreThreshold,
   }),
   isOpenCvLoaded(),
 ]);

 faceDetection = FaceDetection();
 originalImageToProcessCanvas = OffscreenCanvas(srcImageRatio.videoWidth, srcImageRatio.videoHeight);
 originalImageToProcessCanvasCtx = originalImageToProcessCanvas.getContext( );

 resizedImageToProcessCanvas = OffscreenCanvas(
   srcImageRatio.faceDetectionImageWidth,
   srcImageRatio.faceDetectionImageHeight,
 );
 resizedImageToProcessCanvasCtx = resizedImageToProcessCanvas.getContext( ); blazeModel;
}; export const async const null await await const await Promise // The maximum number of faces returned by the model // The width of the input image // The height of the input image // The threshold for deciding whether boxes overlap too much // The threshold for deciding when to remove boxes based on score new new '2d' new '2d' return The method is waiting for openCV to load isOpenCvLoaded isOpenCvLoaded = { timeoutId; resolveOpenCvPromise = { (timeoutId) {
     clearTimeout(timeoutId);
   } { (cv && cv.Mat) { resolve();
     } {
       timeoutId = setTimeout( {
         resolveOpenCvPromise(resolve);
       }, OpenCvLoadedTimeoutInMs);
     }
   } {
     timeoutId = setTimeout( {
       resolveOpenCvPromise(resolve);
     }, OpenCvLoadedTimeoutInMs);
   }
 }; ( {
   resolveOpenCvPromise(resolve);
 });
}; export const => () let const ( ) => resolve if try // eslint-disable-next-line no-undef if return else => () catch => () return new Promise ( ) => resolve Face detection method detectFace = (data, faceModel) => { { originalImageToProcess, lastIndex } = data; facesThumbnailsImageData = []; resizedImageToProcessCanvasCtx.drawImage(
   originalImageToProcess, , ,
   srcImageRatio.faceDetectionImageWidth,
   srcImageRatio.faceDetectionImageHeight,
 ); resizedImageDataToProcess = resizedImageToProcessCanvasCtx.getImageData( , ,
   srcImageRatio.faceDetectionImageWidth,
   srcImageRatio.faceDetectionImageHeight,
 ); predictions = faceModel.estimateFaces( resizedImageDataToProcess, returnTensors, flipHorizontal, annotateBoxes,
 ); predictions = faceDetection.normalizePredictions(
   predictions,
   returnTensors,
   annotateBoxes,
   srcImageRatio.faceDetectionImageRatio,
 ); predictions = faceDetection.filterPredictionsByFullLandmarks(
   predictions,
   srcImageRatio.videoWidth,
   srcImageRatio.videoHeight,
 ); predictions = faceDetection.filterPredictionsByMinWidth(predictions, faceMinWidth, faceMinWidthConversionFactor); predictions = faceDetection.filterPredictionsByRecommendedLocation(predictions, predictionIOU, recommendedLocation); (predictions && predictions.length > ) { originalImageToProcessCanvasCtx.drawImage(originalImageToProcess, , ); originalImageDataToProcess = originalImageToProcessCanvasCtx.getImageData( , ,
     originalImageToProcess.width,
     originalImageToProcess.height,
   ); srcImageData = cv.matFromImageData(originalImageDataToProcess); { ( i = ; i < predictions.length; i++) { prediction = predictions[i]; facesOriginalLandmarks = .parse( .stringify(prediction.originalLandmarks)); (flipHorizontal) { ( j = ; j < facesOriginalLandmarks.length; j++) {
           facesOriginalLandmarks[j][ ] = srcImageRatio.videoWidth - facesOriginalLandmarks[j][ ];
         }
       } dstImageData = cv.Mat(); { thumbnailSize = cv.Size(detectedFaceThumbnailSize, detectedFaceThumbnailSize); transformation = getOneToOneFaceTransformationByTarget(detectedFaceThumbnailSize); similarityTransformation = getSimilarityTransformation(facesOriginalLandmarks, transformation); similarityTransformationMatrix = cv.matFromArray( , , cv.CV_64F, similarityTransformation.data); { cv.warpPerspective(
             srcImageData,
             dstImageData,
             similarityTransformationMatrix,
             thumbnailSize,
             cv.INTER_LINEAR,
             cv.BORDER_CONSTANT, cv.Scalar( , , , ),
           );

           facesThumbnailsImageData.push( ImageData( (dstImageData.data, dstImageData.cols, dstImageData.rows),
               detectedFaceThumbnailSize,
               detectedFaceThumbnailSize,
             ),
           );
         } {
           similarityTransformationMatrix.delete();
           similarityTransformationMatrix = ;
         }
       } {
         dstImageData.delete();
         dstImageData = ;
       }
     }
   } {
     srcImageData.delete();
     srcImageData = ;
   }
 } { resizedImageDataToProcess, predictions, facesThumbnailsImageData, lastIndex };
}; export const async let const // Resize original image to the recommended BlazeFace resolution 0 0 // Getting resized image let 0 0 // Detect faces by BlazeFace let await // The image to classify. Can be a tensor, DOM element image, video, or canvas // Whether to return tensors as opposed to values // Whether to flip/mirror the facial keypoints horizontally. Should be true for videos that are flipped by default (e.g. webcams) // Whether to annotate bounding boxes with additional properties such as landmarks and probability. Pass in `false` for faster inference if annotations are not needed // Normalize predictions // Filters initial predictions by the criteri that all landmarks should be in area of interest // Filters predictions by min face width // Filters predictions by recommended location // If there are any predictions it is started faces thumbnails extraction according to the configured size if 0 // Draw initial original image 0 0 const 0 0 // eslint-disable-next-line no-undef let try for let 0 const const JSON JSON if for let 0 0 0 // eslint-disable-next-line no-undef let new try // eslint-disable-next-line no-undef let new let // eslint-disable-next-line no-undef let // eslint-disable-next-line no-undef let 3 3 try // eslint-disable-next-line no-undef new 127 127 127 255 new new Uint8ClampedArray finally null finally null finally null return The input is an image and an index for face matching and mask detection in the future. Since blazeface accepts images with a maximum size of 128 px, the image from the camera must be reduced. Calling the method starts the image analysis using blazeface, and the predicted coordinates with the coordinates of the face, nose, ears, eyes, mouth area are returned to the main thread. faceModel.estimateFaces Before working with them, you need to restore the coordinates for the original image because we compressed it to 128 px. Now you can use these data to decide whether the face is in the desired area or not. What is the minimum face size you need for subsequent identification. The following code cuts the face out of the image and aligns it to identify the mask using openCV methods. Mask detection Model initialization and backend webAssembly init = (data) => { { backend, streamSettings, maskDetectionsSettings, imageRatio } = data;

 flipHorizontal = streamSettings.flipHorizontal;
 detectedMaskThumbnailSize = maskDetectionsSettings.detectedMaskThumbnailSize;
 srcImageRatio = imageRatio; tfc.setBackend(backend); tfc.ready(); [maskModel] = .all([
   tfconv.loadGraphModel( ,
   ),
 ]);

 detectedMaskThumbnailCanvas = OffscreenCanvas(detectedMaskThumbnailSize, detectedMaskThumbnailSize);
 detectedMaskThumbnailCanvasCtx = detectedMaskThumbnailCanvas.getContext( ); maskModel;
}; export const async const await await const await Promise `/rgb_mask_classification_first/MobileNetV _ / /model.json` ${maskDetectionsSettings.mobileNetVersion} ${maskDetectionsSettings.mobileNetWeight} ${maskDetectionsSettings.mobileNetType} new '2d' return The mask detection requires the coordinates of eyes, ears, nose, mouth, and the aligned image which is returned by the face detection worker. .maskDetectionWorker.postMessage({ : , : lastItem!.data.predictions[ ],
 imageDataToProcess, : lastItem!.index,
}); this type 'detectMask' prediction 0 lastIndex Detection method detectMask = (data, maskModel) => { { prediction, imageDataToProcess, lastIndex } = data; masksScores = []; maskLandmarks = .parse( .stringify(prediction.landmarks)); (flipHorizontal) { ( j = ; j < maskLandmarks.length; j++) {
     maskLandmarks[j][ ] = srcImageRatio.faceDetectionImageWidth - maskLandmarks[j][ ];
   }
 } detectedMaskThumbnailCanvasCtx.putImageData(imageDataToProcess, , ); predictionTensor = tfc.tidy( { maskDetectionSnapshotFromPixels = tfc.browser.fromPixels(detectedMaskThumbnailCanvas); maskDetectionSnapshotFromPixelsFlot32 = tfc.cast(maskDetectionSnapshotFromPixels, ); expandedDims = maskDetectionSnapshotFromPixelsFlot32.expandDims( ); maskModel.predict(expandedDims);
 }); {
   masksScores.push(predictionTensor.dataSync()[ ].toFixed( ));
 } {
   predictionTensor.dispose();
   predictionTensor = ;
 } {
   masksScores,
   lastIndex,
 };
}; export const async let const const JSON JSON if for let 0 0 0 // Draw thumbnail with mask 0 0 // Detect mask via NN let => () let let 'float32' let 0 return // Put mask detection result into the returned array try 0 4 finally null return The result of the neural network is the probability that there is a mask, which is returned from the worker. It helps to increase and decrease the threshold of mask detection. By , we can compare the face and the presence of a mask and display some information on a specific person on the screen. lastIndex Conclusion I hope this article will help you to learn about the possibilities of working with ML in the browser and ways to optimize it. Most applications can be optimized using the tricks described above.

How We Implemented the Face-with-Mask Detection Web App for Chrome

Introduction The main goal is an attempt to detect face and mask in the browser, instead of Python implementation at back-end. This application is a simple webapp / SPA application which contains JS code only and can send some data to a backend for next processing. But initial face and mask detection is done on the browser side, no Python backend implementation is needed. At the current moment, the app works only in the Google Chrome browser. In future articles, I will describe more technical details, the implementation of all our investigation results. There are 2 approaches of how this can be done with browser implementation: TensorFlowJS ONNXJS Both runtimes support WASM, WebGL, and CPU backends. But we will compare only WASM and WebGL, because CPU performance is very low and it can't be used in production. View the demo here TensorFlow.js At the official website, proposes some pre-trained and ready to be used models which includes the appropriate JS postprocessing. For real-time face detection, it is specified in the BlazeFace model, for which . TensorFlow.js an online demo is available More info about BlazeFace can be found . here We created a demo to play a bit with the runtime and model, identify any existing issues. The appropriate links to run the app with different models can be found below: WASM (face detection image size: 160x120; mask detection image size: 64x64px Blaze Face + MobileNet V2 0.35 Blaze Face + MobileNet V2 0.5 Blaze Face + MobileNet V3 0.75 WebGL (face detection image size: 160x120; mask detection image size: 64x64px Blaze Face + MobileNet V2 0.35 Blaze Face + MobileNet V2 0.5 Blaze Face + MobileNet V3 0.75 Performance Results: Getting Frames We can get frames via the appropriate HTML API features. But this process frames consumes time as well. So we need to understand how much time we will spend on such activities. There are the appropriate timing metrics below. Our goal is to detect faces as fast as possible so we should get each frame of the live stream and process. For this issue, we can use which is called every 16.6ms or each frame. requestAnimationFrame Using method of the allows us to take a snapshot of the live video in a and return a promise that resolves with an containing the snapshot. grabFrame() ImageCapture MediaStreamTrack ImageBitmap Single mode it is max performance of getting frame. Sync mode it's how often we can get frame with face detection. Face Detection + Mask Detection Results: Color scheme: red, orange, yellow, fps green < 6 fps 7-12 fps 13-18 fps 19+ Results: We excluded timing metrics from the application start. It is obvious that during the application startup and first runs of the model it will consume more resources/time. When the app is in a warm mode it is worth getting performance metrics only. Warm mode in our case it is just let the app do work 5 - 10 sec and then get performance metrics. Possible inaccuracies in the gathered timings metrics are up to 50ms. The BlazeFace model was developed especially for the mobile devices and helps to achieve good performance with the TFLite inference on Android  and IOS platforms (~50-200 FPS). More info is here . Meanwhile the dataset  for retraining the model from scratch is not available (Google Research Team did not share it). So, there are two model types: Front: Input size 128 x 128px, faster but lower accuracy. Back: Input size 256 x 256px, higher accuracy but slower. This means that the preparation of a detector model with three classes (clear face, face with mask, background) can be a time consuming task. Images Size The original image can be of any size according to the camera settings and business needs. But when we process the frames for face and mask detection the original frame is resized to the appropriate size depending on the model. Image which is used by BlazeFace for face detection is specified with the size 128 x 128px. The original frame is resized to this size considering its proportion. Image which is used by mask detection is specified with the size 64 x 64px. We chose the minimal resolutions for both images taking into account performance requirements and results. Such minimal images demonstrated the best performance results on PC and mobile devices. We use 64 x 64px for thumbnails to detect the mask because size 32 x 32px is not enough for mask detection with sufficient accuracy. How to Get the Best Images to be Analyzed by the Application With TensorFlow.js we have the following options to get the best images to be used in feature by the application: BlazeFace allows you to configure the score for the detected images. We will set this score to high value (>0.9) to avoid any uncertain positives BlazeFace allows you to configure a max amount of faces which are returned from the detection method. We can specify this option to 1 to return 1 face only; we can set it to 2 for example, and in case of 2 faces just to send a message that one person/face can be in front of camera only BlazeFace returns bounding box and landmarks. According to the all-in-one device calibration we have all power in our hands to apply the appropriate checks for these results to be sure if the detected faces are in a good quality. Such checks can be the following: Bounding box should in the calibrated box in X% All N or M from N landmarks should be in the calibrated box Width and height of the bounding box should be above the appropriate thresholds Checks with bounding boxes width/height and landmarks are extremely fast on the client side with JS The selected images according to the specified rules above will be sent to next stages of the pipeline: mask detection. Such logic will provide faster face detection results till the moment when we are sure that the detected face is in a good quality. Mask detection models sizes For mask detection using trained and with different types and multipliers. MobileNetV2 MobileNetV3 We tend to use light or ultra-light models with TensorFlowJS in the browser (< 3Mb). The main reason is the fact that the WASM backend is faster with such models. It is specified in the official documentation and it is confirmed by our performance tests as well. Additional Resources WASM JS back-end: ~60Kb OpenCVJS: 1.6Mb Our SPA itself (+Tensorflow.js): up to 500Kb BlazeFace model is ultra-light: 466Kb For webapp time to interact (TTI) with ~3.5Mb of JS and binary + JSON of size from 1.5Mb to 6Mb (everything will be in internal network) will be >10s in cold mode; in warm mode the expected TTI - 4-5sec. If it is used by web worker(s) and OpenCV.js is used in the worker(s) only it will significantly reduce the size of the main app with 800-900Kb JS, TTI will be 7-8s in cold mode; in warm mode - <5s. Possible approaches to run neural network models in browser: One thread implementation: It is a default implementation for browsers. We run both models for face and mask detections in one thread. A  crucial point is to provide a good performance for both models to be run with any issues in one single thread. It is the current approach which was used to take the performance metrics above. This approach has some limitations. If we would like to add additional models to be run in the pipeline they will be run in the same thread in async way but in sequential flow. It will decrease total performance metrics regarding frames processing. Web Worker(s) usage to run models in different context and have parallelism in the browser: It is used in the main JS thread to run BlazeFace model for face detection, but mask detection is running in a separate thread via web worker. With such implementation we can separate both models running and introduce parallelism for processing in the browser. It will have a positive influence on general UX feeling with the application. Web workers will load TFJS and OpenCV libraries, main JS thread - TF.JS only. It means that the main app will start much faster and by doing it we can significantly reduce TTI time in the browser. Face detection will start more often, it will increase the FPS of the face detection process. As a result mask detection process will be run more often as well and FPS of this process will be increased as well. The expected improvements are up to ~20%. It means that the FPS and MS specified in the article above can be improved by this value. With such an approach to run different models in separate contexts via web workers we can run more neural network models in the browser with good performanсe. The main factor here will be all-in-one device hardware characteristics to support such loading. We have implemented such an approach in the app and it works. But we have some technical issues with postMessage callback when a web worker sends a message back to the main thread. For some reasons it introduces additional delay (up to 200ms on mobile devices) which kill the performance improvement which we achieved with parallelism (this issue actual only for vanilla JS, after implementation in React this issue was fixed) Web Worker Investigation Results Our idea is to use web workers (WW) to run every model in a separate worker/thread/context and achieve model processing parallelism in the browser. But we noticed that the callback function in WW is called with some delays. Below you can find the appropriate investigation measurements and conclusions on what factors it depends on. Test params:
mobileNetVersion=V3
mobileNetVersionMultiplier = mobileNetVersionType = float16
thumbnailSize= px
backend = wasm 0.75 32 In the app we run BlazeFace in main thread and mask detection model in web worker. Here are some measurements for WW processing time on different devices: The results above demonstrate that for some reasons time to send a callback from Web Worker to the main thread depends on the model running or using TensorFlow method in this Web Worker. browser.fromPixels If it is run with a model the callback on MAC OS is sent ~27ms, if model is not run - 5ms. This difference on MAC OS in 22ms can lead to 100-300ms delays on more weak devices and it will have an effect on general app performance with Web Worker usage. Currently we don't understand why it happens but we know the fact that it has happened. How to Increase Accuracy, Decrease False Positives, Run Access Control API for Stable Faces Only We need to have more "context" to take the appropriate decision to inform to face detection and removing mask . Such context is the prev processed frames and their state (is face or not, is face or not, is mask or not). We implemented a "flying" segment to manage such additional context. The length of segment is configurable and depends on the current FPS, but in any case it should not be more than 200-300ms to not introduce visible delays. Below is the appropriate scheme which describes the idea: Conclusions: As stronger device we have as better performance results regarding taking metrics it is demonstrated: For PC we could get the following metrics: Face detection only: >30fps Face detection + mask detection: up yo 45fps For mobile devices we could get the following metrics: Face detection only: from 2.5fps to 12-15fps depends on mobile devices Face detection + mask detection: from 2 to 12fps depends on mobile devices Pay attention that video is always real-time and its performance depends on device itself, but it always will be from 30fps. For mask detection model for the most cases the best results are demonstrated by MobileNetV2 0.35 model, types don't influence the performance metrics with visible effect. Size of the mask detection model depends on types. Since types don't influence performance metrics it is recommended to use uint16 or float16 models to have less model size in the browser and as a result faster TTI. WASM runtime demonstrates better results in comparison with WebGL for BlazeFace model. It is correlated with the : For most models, the WebGL backend will still outperform the WASM backend, however WASM can be faster for ultra-lite models (less than 3MB and 60M multiply-adds). In this scenario, the benefits of GPU parallelization are outweighed by the fixed overhead costs of executing WebGL shaders. official TensorFlowJS documentation regarding performance of small models (<3Mb) TTI time is always better for WASM models in comparison with webgl with the same models configuration. The performance of TensorFlowJS runtime and models can be increased by using to add instructions allowing multiple floating point operations to be vectorized and executed in parallel. Preliminary tests show that enabling these extensions brings 2-3x speedup over WASM today. More info is . It is still an experimental feature which is not delivered with the runtime by default. Also after the release it will be available in the runtime by default or via additional configuration options. WASM extension SIMD here On the client side the expected size of the app is ~3.5Mb of encoded JS with all dependencies, 466Kb of BlazeFace model, from 1.1Mb to 5.6Mb of mask detection model. The expected TTI time for the application is >10sec for mobile devices in cold mode; in warm mode - ~5sec. With web workers usage OpenCV.js can be loaded into web workers only, it significantly reduce TTI for the main app. During our testing we noticed that the devices were very hot. Since it is expected 24/7 availability of the solution this fact can have a big influence on the final decision which devices to use. You need to take this information into account. It is also was noticed that it is better if devices are fully charged and they are connected to the charger during working. In this case the performance of devices according to our observations is better. Charging from USB doesn't allow to support battery on the same level in a long perspective, it should be used for electric charging. This information should be taken into account. In our view even 4-5 fps are enough for the current solution to provide good UX user perception. But it is important to not show bounding boxes or landmarks on the screen, but operate the whole video/screen size: Highlight screen when we captured person. Inform about mask / no mask factor via text messages or another highlighting of the screen. With such a user interacting the delays between realtime and our metadata on the screen will be 200-300ms. Such values will be considered by users of the system as non-critical delays.

We Built a Face and Mask Detection Web App for Google Chrome

In this tutorial I’m going to show you how to create a simple blog using Node.js and Cosmic JS. This is going to be the fastest and most light-weight blog you have ever created. Let’s get started. TL;DR View the demo Install the Simple Blog App on Cosmic JS View the codebase on GitHub Getting Started Make sure that you have and NPM installed on your machine, if not, to install the latest version. Node.js visit the Node.js website Make sure you have installed globally: Yarn npm install yarn -g Let’s start by creating a folder for our app. In your favorite terminal run the following commands: mkdir simple-blog
cd simple-blog Now let’s add a package.json file to import all of our dependencies for our app: vim package.json Add the following to our package.json file: {
  "dependencies": {
    "cosmicjs": "^2.39.0",
    "express": "^4.15.2",
    "hogan-express": "^0.5.2",
    "nodemon": "^1.11.0"
  },
  "scripts": {
    "start": "node app.js",
    "development": "nodemon app.js"
  }
} It’s a pretty light dependency list for a pretty light app. So what we will install is: 1. The Cosmic JS Node Module to get our content from our Cosmic JS Bucket.2. Express for our web app framework3. Hogan for our template views4. Nodemon for development Our scripts are necessary for starting our app in production and development. Run the following command to install our dependencies: yarn Building Our Blog Next, let’s begin building our blog pages. Create a file titled app.js: vim app.js and add the following to app.js: const express = require('express')
const app = express()
const hogan = require('hogan-express')
const http_module = require('http')
const http = http_module.Server(app)
app.engine('html', hogan)
app.set('port', (process.env.PORT || 3000))
app.use('/', express.static(__dirname + '/public/'))
const Cosmic = require('cosmicjs')
const helpers = require('./helpers')
const bucket_slug = process.env.COSMIC_BUCKET || 'simple-blog-website'
const read_key = process.env.COSMIC_READ_KEY
const partials = {
  header: 'partials/header',
  footer: 'partials/footer'
}
app.use('/', (req, res, next) => {
  res.locals.year = new Date().getFullYear()
  next()
})
// Home
app.get('/', (req, res) => {
  Cosmic.getObjects({ bucket: { slug: bucket_slug, read_key: read_key } }, (err, response) => {
    const cosmic = response
    if (cosmic.objects.type.posts) {
      cosmic.objects.type.posts.forEach(post => {
        const friendly_date = helpers.friendlyDate(new Date(post.created_at))
        post.friendly_date = friendly_date.month + ' ' + friendly_date.date
      })
    } else {
      cosmic.no_posts = true
    }
    res.locals.cosmic = cosmic
    res.render('index.html', { partials })
  })
})
http.listen(app.get('port'), () => {
  console.info('==> 🌎  Go to http://localhost:%s', app.get('port'));
}) There are a few things happening here: 1. We are importing our essential modules: Express, Cosmic JS, setting our PORT dynamically, etc.2. We are pointing to some partials: header and footer, you can .3. We view our app home page (‘/’) and query our Cosmic JS Bucket for Post Objects, set the friendly date, then return the index.html template.4. We are also adding our data to this page in the form of a global data store: cosmic. This data structure makes our template implementation super intuitive. reference these partials from the codebase on GitHub Adding Our Home Page Template Variables This part of the process is the most fun because it shows you the power of Cosmic JS combined with a declarative, logic-less template system like . Let’s create a folder called views and add our index.html file: Mustache mkdir views
cd views
vim index.html Add the following to index.html: {{> header }}
  <main class="container">
    {{# cosmic.objects.type.posts }}
      <div class="card" data-href="/{{ slug }}">
        {{# metadata.hero.imgix_url }}
          <div class="blog-post-hero blog-post-hero--short" style="background-image: url({{ metadata.hero.imgix_url }})"></div>
        {{/ metadata.hero.imgix_url }}
        <div class="card-padding">
          <h2 class="blog__title blog__title--small">
            <a href="/{{ slug }}">{{ title }}</a>
          </h2>
          <div class="blog__author">
            <div class="blog__author-image" style="background-image: url({{ metadata.author.metadata.image.imgix_url }}?w=100)"></div>
            <div class="blog__author-title">by <a href="/author/{{ metadata.author.slug }}">{{ metadata.author.title }}</a> on {{ friendly_date }}</div>
            <div class="clearfix"></div>
          </div>
          <div class="blog__teaser droid">{{{ metadata.teaser }}}</div>
          <div class="blog__read-more">
            <a href="/{{ slug }}">Read more...</a>
          </div>
        </div>
      </div>  
    {{/ cosmic.objects.type.posts }}
  </main>
{{> footer }} What’s happening here?1. We pull in our header file with the Mustache template variable.2. We pull in our Cosmic data using the Mustache variable {{ cosmic }} which has everything we need to layout our page’s dynamic data.3. We are looping through our {{ cosmic.objects.type.posts }} and rolling out our blog posts. What I like about this approach is that the template is completely logic-less aside from some boolean queries and array looping. It really does a great job of keeping our logic separate from our presentation (thanks !) Chris Wanstrath If you want to build out the rest of the application, and follow the README instructions. clone the GitHub repo Conclusion This is the abridged version of the available for download in the . The full codebase includes a single post page view as well as a page dedicated to each author’s posts. and deploy this app in a few clicks from your Cosmic JS dashboard by to your Cosmic JS Bucket. Simple Blog app Cosmic JS Apps page View the full codebase on GitHub installing the app I hope you enjoyed this tutorial, if you have any questions and . reach out to us on Twitter join our community on Slack

How to Build a Simple Blog Using Node.js

Tony Spiro is the Co-Founder of , an API-first for building content-powered apps. Cosmic JS Content Management Platform In this tutorial I’m going to show you how to build a user management app using Node.js and the . Cosmic JS CMS API TL;DR View the full source code on GitHub View the Demo The app will include the following pages: Login Signup Users list (logged in user access only) Getting Started Create a file titled app-server.js file and add the following: // app-server.jsimport express from 'express'import hogan from 'hogan-express'import http_module from 'http'import bodyParser from 'body-parser'import compression from 'compression'import session from 'express-session'import config from './config'import cors from 'cors'const app = express()app.use(cors({credentials: true, origin: true}))app.use(bodyParser.json())app.use(compression())app.engine('html', hogan)app.set('views', __dirname + '/views')app.set('port', process.env.PORT || 3000)app.use(express.static(__dirname + '/public'))app.set('trust proxy', 1) // trust first proxyapp.use(session({  secret: 'keyboard cat',  resave: false,  saveUninitialized: true}))app.use((req, res, next) => {  if (req.url === '/favicon.ico')    return res.end()  // Set global variables  res.locals.year = new Date().getFullYear()  // Set dev  if (process.env.NODE_ENV === 'development')    res.locals.is_dev = true  next()})const partials = {  header: 'partials/header',  footer: 'partials/footer'}require('./routes')(app, config, partials)const http = http_module.Server(app)http.listen(app.get('port'), () => {  console.info('==> 🌎  Go to http://localhost:%s', app.get('port'));}) This is the entry point of our app and serves to initialize everything we need for our user management app. We’re using Express for the Node.js framework, Hogan Express for view rendering from Mustache templates. Express Session is used to initialize and save sessions. We are going to have a couple partials available in our templates, header and footer as all of our pages will share these. Know Your Routes Next let’s take a look at index.js in our routes folder. // Routesmodule.exports = (app, config, partials) => {  require('./home')(app, config, partials)  require('./signup')(app, config, partials)  require('./users')(app, config, partials)  require('./auth')(app, config, partials)  require('./logout')(app, config, partials)  require('./404')(app, config, partials)} Here we have all of our routes. Logging In Let’s take a look at home.js which is the login page for our app: // home.jsimport Cosmic from 'cosmicjs'module.exports = (app, config, partials) => {  app.get('/', (req, res) => {    Cosmic.getObjects({ bucket: { slug: config.COSMIC_BUCKET } }, (err, response) => {      res.locals.cosmic = response      if (req.query.message === 'unauthorized')        res.locals.unauthorized_message = true      return res.render('index.html', {        partials      })    })  })} There is not much going on here, just loading our dynamic content from Cosmic JS, as well as the HTML login form. Looking at the auth.js file, you’ll see this is where the login form will send the data to log the user in. // auth.jsimport Cosmic from 'cosmicjs'import async from 'async'import _ from 'lodash'import bcrypt from 'bcrypt'const saltRounds = 10module.exports = (app, config, partials) => {  // Submit form  app.post('/auth', (req, res) => {    const data = req.body    Cosmic.getObjectType({ bucket: { slug: config.COSMIC_BUCKET } }, { type_slug: 'users' }, (err, response) => {      if (err)        res.status(500).json({ status: 'error', data: response })      else {        async.eachSeries(response.objects.all, (user, eachCallback) => {          if (!_.find(user.metafields, { key: 'email', value: data.email.trim().toLowerCase() }))            return eachCallback()          const stored_password = _.find(user.metafields, { key: 'password' }).value          bcrypt.compare(data.password, stored_password, function(err, correct) {            if(correct)              res.locals.user_found = user            eachCallback()          })        }, () => {          if (res.locals.user_found) {            req.session.user = {              first_name: res.locals.user_found.metafield.first_name.value,              last_name: res.locals.user_found.metafield.last_name.value,              email: res.locals.user_found.metafield.email.value            }            req.session.save()            return res.json({ status: 'success', data: response })          }          return res.status(404).json({ status: 'error', message: 'This user was not found or the email and password are incorrect.' })        })      }    })  })} When the data is sent to /auth the Cosmic NPM module searches for the email first then, if found tries to match the submitted password to the password saved in the Cosmic JS API (using ). If both email and password are matched with a user, the session is created and the user is redirected from the login page to the users page. Let’s take a look at the users list page. bcrypt Access Exclusive Content After the user has logged in successfully, they are redirected to the users list page. This is how it looks: app.get('/users', (req, res) => {  if(!req.session.user)    return res.redirect('/?message=unauthorized')  res.locals.user = req.session.user  async.series([    callback => {      Cosmic.getObjectType({ bucket: { slug: config.COSMIC_BUCKET } }, { type_slug: 'users' }, (err, response) => {        res.locals.users = response.objects.all        callback()      })    },    callback => {      Cosmic.getObjects({ bucket: { slug: config.COSMIC_BUCKET } }, (err, response) => {        res.locals.cosmic = response        return res.render('users.html', {          partials        })      })    }  ])}) If the user session is not set, they are immediately redirected to the login page with an unauthorized message. If they have a user session, they will be able to see a list of all registered users (from the Users Object Type). This gives you the idea of how to limit user access in our app. By checking for req.session.user on any page, you can restrict access to logged in users only. Signing Up Let’s take a look at what happens for new users when they post their info to /users: app.post('/users', (req, res) => {  const data = req.body  async.series([    callback => {      let user_found = false      Cosmic.getObjectType({ bucket: { slug: config.COSMIC_BUCKET } }, { type_slug: 'users' }, (err, response) => {        _.forEach(response.objects.all, user => {          if (_.find(user.metafields, { key: 'email', value: data.email.trim() }))            user_found = true        })        if (!user_found)          return callback()        // User found        return res.status(409).json({ status: 'error', message: 'Email already in use' })      })    },    callback => {      bcrypt.hash(data.password, saltRounds, function(err, hash) {        res.locals.hash = hash        callback()      })    },    callback => {      // Send to Cosmic      const object = {        type_slug: 'users',        title: data.full_name,        metafields: [          {            title: 'First name',            key: 'first_name',            type: 'text',            value: data.first_name          },          {            title: 'Last name',            key: 'last_name',            type: 'text',            value: data.last_name          },          {            title: 'Password',            key: 'password',            type: 'text',            value: res.locals.hash          },          {            title: 'Email',            key: 'email',            type: 'text',            value: data.email.trim().toLowerCase()          }        ]      }      if (config.COSMIC_WRITE_KEY)        object.write_key = config.COSMIC_WRITE_KEY      Cosmic.addObject({ bucket: { slug: config.COSMIC_BUCKET } }, object, (err, response) => {        if (err)          res.status(500).json({ status: 'error', data: response })        else          res.json({ status: 'success', data: response })        res.end()      })    }  ])}) There’s a few things happening here. First, the email is checked against the current list of users. If a match is not found, the user object is created with each data point of the user: First Name, Last Name, Email and Password stored as metafields in the Cosmic JS API. Taking this a step further, after you log into your Cosmic JS bucket and go to your Users Object Type you will be able to add more Metafields to the users in your system. This makes adding dynamic, extended data very easy. For example, let’s say you needed to add a profile image, address, GitHub username, etc. All of these can be added as Metafields to the User Object. See screenshot below: See Ya Next Time Now let’s see what happens when a user accesses the /logout route: // logout.jsmodule.exports = (app, config, partials) => {  app.get('/logout', (req, res) => {    req.session.destroy()    return res.redirect('/')  })} The session is simply destroyed and the user is redirected back to the login page. Where’s the HTML? I’m not going to go into too much detail on the HTML, but basically both login and signup forms have JQuery validation and submit AJAX requests to the route endpoints. to see how JQuery is used for this and other UI and UX things. Check out the main.js file on GitHub Conclusion And that’s it. Cosmic JS is a powerful platform for content creation and app data management. With your Cosmic JS-powered User Management App you can now extend your user data using the Cosmic JS API or from your Cosmic JS Bucket Dashboard. I hope you found this tutorial helpful. If you have any questions or feedback you can or . reach out to us on Twitter chat with us in the Slack community

How to Build a Node.js User Management App

Cost-efficiency vs security, speed vs comfort, universality vs self-sufficiency In the fight between mobile devices and desktops for the popularity among users worldwide, the former firmly holds a championship belt. Only in five years, from 2014 to 2019, the have grown by almost five times, from 97.7 billion dollars to 461.7 billion dollars. mobile app revenues At the same time, the growth of the mobile market and increasing opportunities for synchronization between different platforms and devices offers abundant benefits for website owners. They give their web platforms a second life by letting users access them from mobile devices. One of these solutions is a progressive web app. What Is a Progressive Web App? The Progressive Web App is an optimized web platform to be used on a mobile device, a quintessence of web and mobile application, a mobile site built with JavaScript frameworks. Such an app is downloaded directly from a website and opened in a browser – no matter what it is, Safari, Chrome, Firefox, or anything else. Unlike a website customized for mobile, a progressive web app offers full-screen experience, meaning that the user does not see the annoying browser navigation panel. More than that, it works offline since it utilizes cached data. Unlike a mobile application, a progressive web app is fast to load and lightweight. Yet, it does not mean that progressive web apps are a universal and perfect solution. The discussion “PWA vs Native” continues. Nobody talks about the fact that there are also desktop PWAs, but they are much less popular than mobile PWAs. In fact, desktop progressive web apps offer little benefit over websites, so the development of such is a question of personal preference. However, as this technology continues developing, it may open new opportunities and advantages, and, nobody knows, it might become the future of desktop development. What Is a Native App? The native app is a regular mobile application, which is developed particularly for a certain platform or device. When to Choose PWA? If you are on a shoestring budget or if is your first priority, choose PWA. requires a separate development process for each mobile platform. Keep in mind also that Android and iOS are the most popular but not the only mobile platforms available. There are also Windows phones or Amazon devices with their own operating systems and stores. The Chinese market is slowly conquered by their own operating systems. When developing native, you will always be limited to a certain market segment. When , you go global – you develop the app only once and it is suitable for all platforms. cost-efficiency Native app development developing a PWA If you are tired of the of an app to the App Store, PWA is the solution you need. Since such an app is found and downloaded directly from a website, there is no need to be bothered with submitting your app to the store, following all the technical requirement and community guidelines of the OS, and waiting for confirmation. With the help of the PWA technology, implementing minor changing and updating the version is as easy as it only could get. More than that, even if you manage to deploy your app, it does not guarantee that it will be visible for your users. If you open the App Store or Google Play, the top ten apps list will barely differ. It will certainly feature four Facebook apps (Facebook, Messenger, Instagram, and WhatsApp), YouTube, Gmail, and Snapchat. These very apps you will find in almost anybody’s phone. With a native mobile app, you will have to fight for the chance to be seen. With a progressive web app, the situation is different. headache caused by the deployment Here comes another reason to develop a PWA: . Since any PWA is a website by its nature, it is SEO-optimized. Surely, native apps are also optimized using ASO (App Store Optimization) techniques. However, ask any specialist in the field and they tell you that getting high SEO results is way easier than achieving something with ASO. Moreover, Google highly values and prioritizes progressive web apps over traditional websites or regular mobile applications. Respectively, users can easily come across it while googling, which greatly enhances the visibility of your software product. the ability to gain users’ attention If the application is expected to be heavy in terms of and you do not want to compromise on the loading speed, you should go with PWA. When first downloading a PWA, the user does not download all the content of the app as in the case of mobile applications. Respectively, progressive web apps use a very small portion of the phone storage, which will definitely be appreciated by your users. data load Among other benefits of progressive web apps, there is . Sharing the application is as easy as sending a short URL. No need to look for the app in the App Store. No need to search for a website in the browser. A user just opens the link, saves the icon on the home screen, and accesses it anytime in a few simple taps. Another feature users will definitely like is the absence of annoying updates. There is absolutely effort required in their part to keep the app up-to-date. the ability to gain users’ affection and loyalty Talking about , at their official web platform for developers, they have published a telling about the benefits of progressive web apps. According to Google, PWAs are reliable, fast, and engaging. The reliability consists in the fact that these apps load instantly even if a network connection is unstable. PWAs are fast because they are responsive, smooth, and seamlessly loading. They are engaging because they offer full-screen experience with push-notifications and a home screen icon to access it. Respectively, the statistics provided by Google say that PWAs increase engagement and user conversion. For the developers, Google offers a step-by-step course on PWA development. Google statement Meanwhile, no such statement about PWAs has been issued by . This tech giant allegedly supports the advancement of the PWA technology but pays little effort or attention towards actually developing it. Respectively, it is believed that iOS devices display progressive web apps not as good as Android. Apple A nice bonus: PWAs are suitable for the business of any size. PWAs are a good option is you have a small business or a start-up. Since the is simpler, faster, and cheaper, it may be more affordable and suitable for your emerging business than launching a long-lasting and badly expensive process. At the same time, it does not mean that, as a medium-sized or large business, you should give up on this idea. Progressive web apps proved themselves to be effective for such tech giants as Facebook, Pinterest, and Twitter since they offer a significant business development value. development of progressive web apps mobile development When to Choose Native? You should choose native when you want to be . Not all the browsers on all the devices can display PWAs perfectly, and as a business owner, you will have absolutely no power to change it. Also, native applications offer more opportunities in terms of UI/UX than PWAs. For instance, PWAs do not give an opportunity to use 3D. keeping everything under control Developing a native application is what you should choose when the of your future app needs to be quite complicated. Some functions of a phone are available for native mobile apps and unavailable for progressive web applications. For instance, a PWA cannot use Bluetooth, which is necessary for connecting with smart devices or using indoor geolocation. functionality If you prioritize , you should go with native apps.  Web platforms have always been known to be more prone to a data breach than mobile applications. While PWAs are protected with security protocols, native apps still remain a safer and more hacker-resistant option. data security If your business has and you do not plan to develop one, choose native – there is no point for you to develop a PWA. The very idea of PWA is to communicate with your target users directly via the website. If you do not have a website, why would you need a progressive web app? In turn, native applications are more self-sufficient in a way that they can function without any additional web support. no website Another opportunity that only native apps offer is . GEO-fencing is a technique which enables businesses to track the movement of people nearby and to act accordingly. For instance, stores can send notifications to a user when they come into close proximity to their physical location. In this way, they inform the customer about the store, draw their attention, and maybe give a discount or a special offer to encourage them to enter. Whereas PWAs can use the location feature to allocate the device, GEO-fencing is not available for them. GEO-fencing To Wrap Up “Progressive Web Apps vs Native” is a discussion, not a competition. The major difference is that a mobile app is written to run on a mobile device, while a progressive web app is written to run in a browser: the web page loads – the app is running. There are both instances when progressive web apps are a better choice and cases when native apps are more suitable. The main idea is to understand the needs of your business and to find the best solution to meet them. Ask yourself four questions concerning the background of your application, the development process, user experience, and platforms that you target. Background If you need to develop a self-sufficient application, choose native. If you need to develop an application that would support your website, choose PWA. Development process If you strive to keep everything under control, choose native. If you strive to accelerate, facilitate, and cheapen the development process, choose PWA. User experience If you prioritize user’s safety and comfort, choose native. If you prioritize convenience and loading speed, choose PWA. Platform If you focus on developing apps for Android devices or for both Android and iOS, choose PWA. If you stick exclusively to Apple, choose native. In case you need any advice or help, please contact me via maxim.savonin@keenethics.com. Thanks to Tania Matviiok for helping me with the article.

Stories, News & Mentions about MOBILESERVE

Mobileserve’s Stories on HackerNoon