The document provides an introduction to building a simple web server in Node.js. It discusses organizing the code into modules, including a server module to start the web server, a routes module to route requests, and a request handlers module. It also covers basic concepts like using the http module to create a server, handling requests, and returning responses. The server currently returns the same "Hello World" response for all requests, and next steps involve routing requests to proper handlers to return the appropriate content based on the URL.
This document provides an overview of ExpressJS, a web application framework for Node.js. It discusses using Connect as a middleware framework to build HTTP servers, and how Express builds on Connect by adding functionality like routing, views, and content negotiation. It then covers basic Express app architecture, creating routes, using views with different template engines like Jade, passing data to views, and some advanced topics like cookies, sessions, and authentication.
The document discusses Node.js and Express.js concepts for building web servers and applications. It includes examples of creating HTTP servers, routing requests, using middleware, handling errors, templating with views and layouts, and separating code into models and routes.
Node.js is an open source JavaScript runtime environment used to build real-time web applications. The document introduces Node.js, the npm package manager, the Express web application framework, and how to connect a Node.js application to MongoDB. Key points covered include Node.js being single-threaded and event-driven, using npm to install and use packages locally or globally, Express providing features for building web apps and APIs, and using modules like Mongoose to connect a Node app to MongoDB.
Plain React detects changes by re-rendering your whole UI into a virtual DOM and then comparing it to the old version. Whatever changed, gets patched to the real DOM.
NodeJS is an open source, cross platform run time environment for server side and networking application. NodeJS is popular in development because front & back end side both uses JavaScript Code.
NestJS (https://nestjs.com/) is a Node.js framework for building server-side applications. This slide give you a brief introduction of Nest, and shows the examples like Service, Middleware, and Pipe, etc.
This document provides an overview and introduction to React JS. It discusses that React JS is a JavaScript library developed by Facebook for building user interfaces and reusable UI components. It encourages creation of reusable components that present data that changes over time. The document also covers React JS features, architecture, components, best practices, pros and cons, and provides useful links for examples and environment setup.
The document provides an overview of React including its introduction, prerequisites, installation, fundamentals, components, life cycle, routing, hooks, Redux, projects, testing, comparison to Angular, and tips for React developers. It discusses key React concepts such as JSX, props, state, events, DOM, and virtual DOM.
This document provides an introduction and overview of Reactjs including:
1. Reactjs core concepts including components, virtual DOM, and JSX
2. React components are self-contained reusable blocks and many companies have open sourced React component libraries
3. The React lifecycle methods for components including initialization, update, and destruction
Getting started with the reactjs, basics of reactjs, introduction of reactjs, core concepts of reactjs and comparison with the other libraries/frameworks
This document provides an introduction and overview of Node.js, including what Node.js is, its architecture and basics, how to write "Hello World" programs in Node.js and Express, how to use modules, errors, middleware, routers, Mongoose and MongoDB for databases, and the MEAN stack. It also describes a tutorial for building a backend API with Node.js, Express, Mongoose and MongoDB.
React Js Basic Details and Descriptions
Frontend Javascript Library, to make decent SPA
The fastest way to build a segregated component based front end for software development.
Node.js is a server-side JavaScript platform built on Google's V8 engine. It is non-blocking and asynchronous, making it suitable for data-intensive real-time applications. The document discusses how to install Node.js and its dependencies on Ubuntu, introduces key Node.js concepts like events and the event loop, and provides examples of popular Node.js packages and use cases.
The document outlines the agenda for a presentation on Node.js, which includes defining what Node.js is, how it works, examples of its use, how to learn Node.js, and what problems it is well-suited to solve. Key points are that Node.js is a JavaScript runtime built on Chrome's V8 engine, uses non-blocking I/O, and is well-suited for building microservices and real-time applications that require high throughput and scalability. Recommended resources for learning more include nodeschool.io, codewars.com, and nodeup.com.
JavaScript is a scripting language originally designed for web browsers but now used everywhere. It has dynamic typing and supports object-oriented, imperative, and functional programming. JavaScript was created in 1995 and standardized in 1999. It is now the most popular language on GitHub. JavaScript can be used to build interactive web pages, desktop applications, server-side applications, IoT applications, and real-time applications. The core data types in JavaScript are Number, String, Boolean, Object, Function, Array, Date, and Regular Expressions. JavaScript supports features like variables, flow control, error handling, debugging, and JSON for data exchange.
React is a JavaScript library for building user interfaces. It was created by Facebook and is best for building dynamic websites like chat applications. React uses a virtual DOM for efficiently updating the view after data changes. Components are the building blocks of React and can contain state and props. The document provides an example of a simple component class and demonstrates how to add state and props. It also includes links to example code and MicroPyramid's social media profiles.
Slides from the NestJS MasterClass.
We learned how to build JavaScript server-side applications with NestJS - A progressive NodeJS framework built with TypeScript.
You can find the code on GitHub:
https://github.com/nirkaufman/task-manager
This document provides an introduction to React.js, including:
- React.js uses a virtual DOM for improved performance over directly manipulating the real DOM. Components are used to build up the UI and can contain state that updates the view on change.
- The Flux architecture is described using React with unidirectional data flow from Actions to Stores to Views via a Dispatcher. This ensures state changes in a predictable way.
- Setting up React with tools like Browserify/Webpack for module bundling is discussed, along with additional topics like PropTypes, mixins, server-side rendering and React Native.
Node.js is a server-side JavaScript platform that allows building scalable network applications quickly. It uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. Node.js runs on a single thread event loop, handles concurrent connections without blocking and takes advantage of asynchronous programming. It is commonly used for real-time applications that require two-way communication between client and server like chat, streaming etc.
The document is a presentation about Node.js, a JavaScript runtime built on Chrome's V8 JavaScript engine. It discusses how Node.js uses an event-driven, non-blocking I/O model that makes it particularly suited for real-time web applications and I/O-intensive applications compared to traditional threaded server models. It provides examples of Node.js features like asynchronous I/O, event loops, modules and the npm package manager.
Original slides from Ryan Dahl's NodeJs intro talkAarti Parikh
These are the original slides from the nodejs talk. I was surprised not find them on slideshare so adding them. The video link is here https://www.youtube.com/watch?v=ztspvPYybIY
This document summarizes key features of Google Web Toolkit (GWT):
- GWT allows developing AJAX applications in Java, with the code compiling to optimized JavaScript. It handles cross-browser issues and allows debugging like a standard Java application.
- GWT includes easy to use widgets, remote procedure calls (RPC) mechanism, internationalization support, and history handling. It also supports JSON, deferred binding, and native JavaScript integration.
- New features in GWT 2.0 include an in-browser development mode, speed tracer for performance analysis, code splitting for faster loading, declarative UI creation, and resource bundles for optimized downloads.
This document provides an introduction and overview of Node.js. It discusses the brief history of server-side JavaScript, how Node.js was created to enable easy push capabilities for websites, and its growth in popularity in the following years. The document also covers key aspects of Node.js like non-blocking I/O, event loops, streams, modules, and dependency management with NPM. Popular frameworks like Express, Hapi, and tools/concepts like IoT, desktop apps, and real-time apps are also mentioned.
Slides from my workshop about node.js which I conducted in Girl Geek Dinner Bangalore. More details at http://sudarmuthu.com/blog/introduction-to-node-js-at-yahoo-girl-geek-dinner
This document provides an introduction to asynchronous programming in Python using asyncio. It defines asyncio as a module that provides infrastructure for writing single-threaded concurrent code using coroutines. It discusses how asyncio allows I/O to be handled asynchronously using coroutines and without blocking threads. It highlights some benefits of asyncio like improved performance and scalability for web applications by allowing many network connections to be handled simultaneously without blocking. It provides examples of how to get started with asyncio by running coroutines concurrently using tasks and futures.
The document describes a practical training project to develop a job portal website using PHP at Masters Infosoft Pvt. Ltd. in Jaipur, India by Arjun lal Kumawat, a student at Sobhasaria Engineering College. It discusses the objectives, scope, system analysis and design, hardware and software requirements, data flow diagram, and testing of the job portal website project.
Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient, perfect for data-intensive real-time applications that run across distributed devices.
Node.js is an open source command line tool built for the server side JavaScript code.
Event-driven IO server-side JavaScript environment based on V8 EngineRicardo Silva
This document contains information about Ricardo Silva's background and areas of expertise. It includes his degree in Computer Science from ISTEC and MSc in Computation and Medical Instrumentation from ISEP. It also notes that he works as a Software Developer at Shortcut, Lda and maintains a blog and email contact for Node.js topics. The document then covers several JavaScript, Node.js and Websockets topics through examples and explanations in 3 sentences or less each.
The document provides an introduction to server-side JavaScript using Node.js. It discusses Node.js basics, how it uses an event-driven and non-blocking model, and provides examples of building HTTP and TCP servers. It also covers Node.js modules, benchmarks, when to use/not use Node.js, and popular companies using Node.js in production.
Windows Phone 8 - 3.5 Async ProgrammingOliver Scheer
This document discusses asynchronous programming in C# using async and await. It explains how await works by suspending method execution and resuming it later. This allows asynchronous code to appear synchronous to callers. It also shows how tasks can be used to execute code asynchronously and support features like progress reporting and cancellation previously handled by BackgroundWorker.
This document provides an overview of server-side JavaScript using Node.js in 3 sentences or less:
Node.js allows for the development of server-side applications using JavaScript and non-blocking I/O. It introduces some theory around event loops and asynchronous programming in JavaScript. The document includes examples of building HTTP and TCP servers in Node.js and connecting to MongoDB, as well as when Node.js may and may not be suitable.
Possibility of arbitrary code execution by Step-Oriented Programmingkozossakai
Step-Oriented Programming (SOP) allows executing arbitrary code on embedded systems by repeating step execution and changing the program counter value. A debugger communicates with a target system's stub using the Remote Serial Protocol to read/write memory and registers, enabling full control via simple commands if the connection is compromised. SOP constructs code by combining pieces of existing machine code and executes it without needing to directly inject new code. Therefore attacks are possible even if execution from data areas is prevented. The presentation will demonstrate this attack principle and results from actual experimentation.
Possibility of arbitrary code execution by Step-Oriented Programming by Hiroa...CODE BLUE
An embedded system has a stub to connect with a host PC and debug a program on the system remotely. A stub is an independent control program that controls a main program to enable debugging by a debugger. A stub is simplified by only processing the simple controls such as reading or writing of the register or of a memory, and a debugger processes a complicated analysis on the host PC.
Communication with a debugger on the host PC and a stub on the embedded system is performed by a protocol called Remote Serial Protocol (RSP) over a serial communication or TCP/IP communication. If this communication is taken away, it becomes possible to operate a stub arbitrarily. We considered what kind of attack possibility there was in that case, and identified that execution of arbitrary code constructed from pieces of machine code, combined with (SOP: Step-Oriented Programming) is possible by repeating step execution while changing the value of the program counter. Therefore it is possible to construct an arbitrary code and execute it from existing machine code, even if execution of the injected machine code is impossible because execution on data area is prevented by DEP or only machine code on the flash ROM are allowed execution.
I will explain about an attack principle by SOP and the results from constructed attack code and actual inspection.
Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. It uses event-driven, non-blocking I/O model which makes it lightweight and efficient for data-intensive real-time applications that run across distributed devices. Node.js runs in a single thread without blocking, utilizing callbacks and events to handle concurrency. It is commonly used for building fast and scalable network applications.
Node.js is a JavaScript runtime environment for building fast and scalable network applications. It uses non-blocking I/O and event-driven architecture, allowing it to handle multiple connections simultaneously without blocking. This makes Node.js suitable for real-time web applications with many simultaneous connections. Node.js has a small core but is extensible through modules. Common modules include Express for building web servers and Socket.IO for real-time web functionality. While Node.js is well-suited for I/O-intensive applications, it is less suitable for CPU-intensive or memory-intensive applications due to its single-threaded nature.
Node.js is an asynchronous event-driven JavaScript runtime that allows JavaScript to be used on the server-side. It uses a non-blocking I/O model that makes it suitable for real-time web applications. WebSockets provide a standardized way for the browser and server to establish two-way communication. However, not all browsers support WebSockets yet. Socket.io addresses this by providing a WebSocket-like experience across all browsers through fallbacks like long-polling. It allows real-time applications to be developed more easily.
Sphinx is the open-source tool for converting reStructured Text into various formats for publishing product documentation. This deck talks about getting started with authoring documentation using Sphinx
This document summarizes a large fintech company in the Philippines' journey to Kubernetes. It faced challenges of legacy systems, static vs dynamic infrastructure, on-prem vs cloud, and security. It adopted a microservices architecture running on Kubernetes with Docker containers. It started with multiple small clusters but consolidated to a single large cluster with namespace isolation for improved cost and manageability. Automations were implemented for operations. Monitoring and logging were set up with ELK and Prometheus/Grafana. A10 was selected for traffic management and security between services. The final deployment provides north-south load balancing and security and east-west traffic security and visibility between microservices.
Security and Observability of Application Traffic in KubernetesAkshay Mathur
Advance Load Balancers in containerized form can provide security and observability into traffic, improve application response time and lower down overall operational burden.
In Kubernetes env East-West traffic security and access control between microservices is very important especially when it is done effectively without imposing a lot of cost overhead.
Considerations for East-West Traffic Security and Analytics for Kubernetes En...Akshay Mathur
This document discusses considerations for securing east-west traffic in Kubernetes environments. It notes growing adoption of containers and Kubernetes for application deployments. Key requirements are discussed like efficient operations, visibility and control, and application security. Common issues in Kubernetes include lack of access control between microservices and lack of application layer visibility. The document then explores potential solutions like using an ingress controller and transparent proxy to provide traffic management, access control policies, and encryption without requiring code changes. It proposes a distributed architecture with a central controller to keep configurations in sync and provide analytics on application traffic and security.
Kubernetes as Orchestrator for A10 Lightning ControllerAkshay Mathur
The document discusses using Kubernetes as an orchestrator for A10 Lightning Controller. Some key points:
1) Kubernetes allows for automatic recovery of pods on failure, easy rolling upgrades of code, and automated scaling of microservices.
2) Using Kubernetes allows the controller to be deployed on-premise and scaled across multiple VMs, with automated launching and scaling. Installation is also now independent of the underlying infrastructure.
3) The journey involved moving from a manual deployment to a Kubernetes deployment, which simplified overlay networking, environment variable passing, and simplified adding/replacing nodes.
Solution for using AWS cloud on the fly for an application deployed in data centre. Dynamically start additional instance in AWS using monitoring and triggers from A10 Lightning Application Delivery Service (ADS) and AWS Lambda.
Shared Security Responsibility Model of AWSAkshay Mathur
I heard many people saying that they need not worry about security of their application (or it is automatically PCI compliant) just because the application is hosted in AWS EC2.
This was presented in AWS meetup to make it clear to audience that security is shared responsibility. While AWS takes care of security at L1 & L2 and provide tools for L3 & L4, we need to take care of security at L7 (Application layer)
Techniques for scaling application with security and visibility in cloudAkshay Mathur
Akshay Mathur gives a presentation on techniques for scaling applications with security and visibility in the cloud. He discusses 8 growth phases applications typically go through including load balancing, gaining insights, content optimization, offloading services, content switching, preventing bot traffic and DDoS attacks, continuous delivery, and the need for a unified cloud application front end solution to manage these phases. He introduces Appcito CAFE as a service that provides capabilities across availability, performance, security and DevOps to simplify application scaling in the cloud.
Object Oriented Programing in JavaScriptAkshay Mathur
This document discusses object oriented programming concepts in JavaScript, including objects, custom objects, object as namespaces, object as named arguments, functions, function arguments, naming functions, variable scope, return values, and classes. It provides examples of defining objects, custom objects, passing objects to functions, defining functions, function arguments, variable scope, return values, and using functions as objects to emulate classes in JavaScript.
This is an effort towards teaching Angular JS from what an average Javascript developer already know. The presentation tries to fill the gap rather than posing Angular as a magical framework.
Releasing Software Without Testing TeamAkshay Mathur
The document discusses the challenges with the traditional software development model of having separate development and testing teams. It argues that having a single team responsible for both development and testing has several advantages, including encouraging developers to adopt a "test-first" approach, eliminating overhead from inter-team coordination, and reducing bug resolution times. The document also examines how requirements are often unclear and changing, which disrupts the linear waterfall model and makes it difficult for separate teams to work together effectively.
The document discusses creating web applications using jQuery. It begins with introductions and background on the speaker's experience. It then discusses how JavaScript can become complex when building real-world applications, but common requirements emerge a pattern. JavaScript frameworks help simplify coding through interfaces and syntactic sugar. jQuery is introduced as a popular framework that handles cross-browser compatibility issues and simplifies DOM manipulation through selectors and functions. The document then covers various jQuery topics like versions, objects, selectors, reading/manipulating the DOM, events, and communicating with servers.
CoffeeScript is a language that compiles to JavaScript. It simplifies JavaScript syntax by removing semicolons and curly braces, using indentation to define code blocks instead. CoffeeScript provides syntactic sugar that generates cleaner JavaScript code. Variables are private by default and functions return the last statement. CoffeeScript uses operators like 'is' and 'isnt' instead of '==' and '!=' and loops through arrays and objects differently than JavaScript.
Creating Single Page Web App using Backbone JSAkshay Mathur
This was presented during the workshop on the topic. The complete code of the app that was created during the workshop is available at Github https://github.com/mathurakshay/explore-venues
This document provides an overview and introduction to web development. It discusses ground rules for the session and asks attendees to introduce themselves. It then introduces the presenter, Akshay Mathur, and his background. The document proceeds to define what the web is and its evolution from static pages in Web 1.0 to dynamic pages in Web 2.0 powered by technologies like JavaScript, AJAX, and DOM manipulation. It covers key concepts like the URL, webpage structure, and HTML tags. It also provides introductions to CSS, JavaScript, and how to make pages dynamic using server-side technologies.
The document provides an overview of a workshop on creating single page web applications using JavaScript. The workshop will be conducted over 3 full days and cover building simple web pages with HTML and CSS, adding dynamic functionality with JavaScript, and developing a single page application using frameworks like Backbone.js. The first day will introduce HTML, DOM manipulation with JavaScript, and responsive design. The second day focuses on jQuery, AJAX, templates and CoffeeScript. The third day covers MVC principles, and building a single page app with Backbone.js and Underscore.js.
The document provides an overview of Google App Engine (GAE), including available services, common use cases, and best practices for developing applications on the platform. It discusses how GAE offers scalable hosting as a Platform as a Service (PaaS), with free quotas and no server management required. The document also outlines common strategies for structuring GAE applications, accessing data storage and APIs, and deploying code.
Managing Files with GIT is a document about using the version control system Git. It discusses how Git helps keep track of file changes, allows easy sharing of work, and provides tools to manage diverging code streams through features like branching and merging. The key aspects of using Git covered are initializing repositories, adding and committing files, branching, merging, resolving conflicts, and best practices for collaborative work.
This document provides an overview and agenda for a session on testing single-page web applications. It introduces the concepts of traditional and modern web applications, and how they differ in terms of page construction and the challenges they pose for testing. It then discusses technologies like Node.js, headless browsers, CasperJS and Splinter that help enable testing of dynamic DOM in single-page apps from outside the browser or without opening the browser. The agenda involves demonstrating how to test a UI using these tools by invoking tests from the Python console or command line.
How to Avoid Learning the Linux-Kernel Memory ModelScyllaDB
The Linux-kernel memory model (LKMM) is a powerful tool for developing highly concurrent Linux-kernel code, but it also has a steep learning curve. Wouldn't it be great to get most of LKMM's benefits without the learning curve?
This talk will describe how to do exactly that by using the standard Linux-kernel APIs (locking, reference counting, RCU) along with a simple rules of thumb, thus gaining most of LKMM's power with less learning. And the full LKMM is always there when you need it!
AC Atlassian Coimbatore Session Slides( 22/06/2024)apoorva2579
This is the combined Sessions of ACE Atlassian Coimbatore event happened on 22nd June 2024
The session order is as follows:
1.AI and future of help desk by Rajesh Shanmugam
2. Harnessing the power of GenAI for your business by Siddharth
3. Fallacies of GenAI by Raju Kandaswamy
Performance Budgets for the Real World by Tammy EvertsScyllaDB
Performance budgets have been around for more than ten years. Over those years, we’ve learned a lot about what works, what doesn’t, and what we need to improve. In this session, Tammy revisits old assumptions about performance budgets and offers some new best practices. Topics include:
• Understanding performance budgets vs. performance goals
• Aligning budgets with user experience
• Pros and cons of Core Web Vitals
• How to stay on top of your budgets to fight regressions
Interaction Latency: Square's User-Centric Mobile Performance MetricScyllaDB
Mobile performance metrics often take inspiration from the backend world and measure resource usage (CPU usage, memory usage, etc) and workload durations (how long a piece of code takes to run).
However, mobile apps are used by humans and the app performance directly impacts their experience, so we should primarily track user-centric mobile performance metrics. Following the lead of tech giants, the mobile industry at large is now adopting the tracking of app launch time and smoothness (jank during motion).
At Square, our customers spend most of their time in the app long after it's launched, and they don't scroll much, so app launch time and smoothness aren't critical metrics. What should we track instead?
This talk will introduce you to Interaction Latency, a user-centric mobile performance metric inspired from the Web Vital metric Interaction to Next Paint"" (web.dev/inp). We'll go over why apps need to track this, how to properly implement its tracking (it's tricky!), how to aggregate this metric and what thresholds you should target.
Details of description part II: Describing images in practice - Tech Forum 2024BookNet Canada
This presentation explores the practical application of image description techniques. Familiar guidelines will be demonstrated in practice, and descriptions will be developed “live”! If you have learned a lot about the theory of image description techniques but want to feel more confident putting them into practice, this is the presentation for you. There will be useful, actionable information for everyone, whether you are working with authors, colleagues, alone, or leveraging AI as a collaborator.
Link to presentation recording and transcript: https://bnctechforum.ca/sessions/details-of-description-part-ii-describing-images-in-practice/
Presented by BookNet Canada on June 25, 2024, with support from the Department of Canadian Heritage.
How Netflix Builds High Performance Applications at Global ScaleScyllaDB
We all want to build applications that are blazingly fast. We also want to scale them to users all over the world. Can the two happen together? Can users in the slowest of environments also get a fast experience? Learn how we do this at Netflix: how we understand every user's needs and preferences and build high performance applications that work for every user, every time.
Video traffic on the Internet is constantly growing; networked multimedia applications consume a predominant share of the available Internet bandwidth. A major technical breakthrough and enabler in multimedia systems research and of industrial networked multimedia services certainly was the HTTP Adaptive Streaming (HAS) technique. This resulted in the standardization of MPEG Dynamic Adaptive Streaming over HTTP (MPEG-DASH) which, together with HTTP Live Streaming (HLS), is widely used for multimedia delivery in today’s networks. Existing challenges in multimedia systems research deal with the trade-off between (i) the ever-increasing content complexity, (ii) various requirements with respect to time (most importantly, latency), and (iii) quality of experience (QoE). Optimizing towards one aspect usually negatively impacts at least one of the other two aspects if not both. This situation sets the stage for our research work in the ATHENA Christian Doppler (CD) Laboratory (Adaptive Streaming over HTTP and Emerging Networked Multimedia Services; https://athena.itec.aau.at/), jointly funded by public sources and industry. In this talk, we will present selected novel approaches and research results of the first year of the ATHENA CD Lab’s operation. We will highlight HAS-related research on (i) multimedia content provisioning (machine learning for video encoding); (ii) multimedia content delivery (support of edge processing and virtualized network functions for video networking); (iii) multimedia content consumption and end-to-end aspects (player-triggered segment retransmissions to improve video playout quality); and (iv) novel QoE investigations (adaptive point cloud streaming). We will also put the work into the context of international multimedia systems research.
Quality Patents: Patents That Stand the Test of TimeAurora Consulting
Is your patent a vanity piece of paper for your office wall? Or is it a reliable, defendable, assertable, property right? The difference is often quality.
Is your patent simply a transactional cost and a large pile of legal bills for your startup? Or is it a leverageable asset worthy of attracting precious investment dollars, worth its cost in multiples of valuation? The difference is often quality.
Is your patent application only good enough to get through the examination process? Or has it been crafted to stand the tests of time and varied audiences if you later need to assert that document against an infringer, find yourself litigating with it in an Article 3 Court at the hands of a judge and jury, God forbid, end up having to defend its validity at the PTAB, or even needing to use it to block pirated imports at the International Trade Commission? The difference is often quality.
Quality will be our focus for a good chunk of the remainder of this season. What goes into a quality patent, and where possible, how do you get it without breaking the bank?
** Episode Overview **
In this first episode of our quality series, Kristen Hansen and the panel discuss:
⦿ What do we mean when we say patent quality?
⦿ Why is patent quality important?
⦿ How to balance quality and budget
⦿ The importance of searching, continuations, and draftsperson domain expertise
⦿ Very practical tips, tricks, examples, and Kristen’s Musts for drafting quality applications
https://www.aurorapatents.com/patently-strategic-podcast.html
How RPA Help in the Transportation and Logistics Industry.pptxSynapseIndia
Revolutionize your transportation processes with our cutting-edge RPA software. Automate repetitive tasks, reduce costs, and enhance efficiency in the logistics sector with our advanced solutions.
MYIR Product Brochure - A Global Provider of Embedded SOMs & SolutionsLinda Zhang
This brochure gives introduction of MYIR Electronics company and MYIR's products and services.
MYIR Electronics Limited (MYIR for short), established in 2011, is a global provider of embedded System-On-Modules (SOMs) and
comprehensive solutions based on various architectures such as ARM, FPGA, RISC-V, and AI. We cater to customers' needs for large-scale production, offering customized design, industry-specific application solutions, and one-stop OEM services.
MYIR, recognized as a national high-tech enterprise, is also listed among the "Specialized
and Special new" Enterprises in Shenzhen, China. Our core belief is that "Our success stems from our customers' success" and embraces the philosophy
of "Make Your Idea Real, then My Idea Realizing!"
UiPath Community Day Kraków: Devs4Devs ConferenceUiPathCommunity
We are honored to launch and host this event for our UiPath Polish Community, with the help of our partners - Proservartner!
We certainly hope we have managed to spike your interest in the subjects to be presented and the incredible networking opportunities at hand, too!
Check out our proposed agenda below 👇👇
08:30 ☕ Welcome coffee (30')
09:00 Opening note/ Intro to UiPath Community (10')
Cristina Vidu, Global Manager, Marketing Community @UiPath
Dawid Kot, Digital Transformation Lead @Proservartner
09:10 Cloud migration - Proservartner & DOVISTA case study (30')
Marcin Drozdowski, Automation CoE Manager @DOVISTA
Pawel Kamiński, RPA developer @DOVISTA
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
09:40 From bottlenecks to breakthroughs: Citizen Development in action (25')
Pawel Poplawski, Director, Improvement and Automation @McCormick & Company
Michał Cieślak, Senior Manager, Automation Programs @McCormick & Company
10:05 Next-level bots: API integration in UiPath Studio (30')
Mikolaj Zielinski, UiPath MVP, Senior Solutions Engineer @Proservartner
10:35 ☕ Coffee Break (15')
10:50 Document Understanding with my RPA Companion (45')
Ewa Gruszka, Enterprise Sales Specialist, AI & ML @UiPath
11:35 Power up your Robots: GenAI and GPT in REFramework (45')
Krzysztof Karaszewski, Global RPA Product Manager
12:20 🍕 Lunch Break (1hr)
13:20 From Concept to Quality: UiPath Test Suite for AI-powered Knowledge Bots (30')
Kamil Miśko, UiPath MVP, Senior RPA Developer @Zurich Insurance
13:50 Communications Mining - focus on AI capabilities (30')
Thomasz Wierzbicki, Business Analyst @Office Samurai
14:20 Polish MVP panel: Insights on MVP award achievements and career profiling
1. A K S H A Y M A T H U R
@AKSHAYMATHU
Getting Started with
2. Ground Rules
@akshaymathu
2
Post on FB and Tweet now
Disturb Everyone during the
session
Not by phone rings
Not by local talks
By more information and
questions
3. Let’s Know Each Other
@akshaymathu
3
Do you code?
OS?
Node?
JavaScript, JSON?
Web Development?
CoffeeScript
Other Programing Language?
Why are you attending?
4. Akshay Mathur
@akshaymathu
4
Founding Team Member of
ShopSocially (Enabling “social” for retailers)
AirTight Neworks (Global leader of WIPS)
15+ years in IT industry
Currently Principal Architect at ShopSocially
Mostly worked with Startups
From Conceptualization to Stabilization
At different functions i.e. development, testing, release
With multiple technologies
5. JavaScript
@akshaymathu
5
Born in 1995 at Netscape
Not at all related to Java
Syntax influenced by C
Interpreted ECMA scripting language
Dynamically typed
Object Oriented as well as Functional
Prototype based
6. Typical Usage
@akshaymathu
6
Web programing
Client side
Web pages
Browser plugins
Server side
SSJS (not in use)
NodeJS
PDF documents
Desktop Widgets
MongoDB
7. NodeJS
JavaScript Runtime at command line
Allows us to write JS programs outside browser
Built on V8 JS engine
V8 is open source JS engine developed by Google
It also powers Google Chrome
Written in C++
Compiles JS code to native before execution
@akshaymathu
7
8. Good for
For IO heavy apps
Web socket (chat) server
Real time collaborative editor
Fast file uploads
Ad server
Any other real time data app (e.g. streaming server)
Crawler
Asynchronous chaining of tasks
NOT good for CPU heavy apps
Weather prediction
May not be good for big projects
@akshaymathu
8
9. NodeJS is NOT
A web framework
Provides tools to create a web server
Multi threaded
Is Single threaded, event driven, asynchronous, non-blocking
For beginners
Needs programing at very low level
You start with writing a web server
@akshaymathu
9
10. Possible Issues
@akshaymathu
10
Can not utilize multicore processer because of single
thread
Managing multiple processes from outside may be even bigger
problem
Any CPU intensive task delays all the requests
Requires constant attention (non-traditional thinking)
for not having blocking code
In case of big products the code/logic gets distributed in
multiple callback functions
If data needs to collected from different places and
correlated, synchronizing all callbacks becomes tough
Garbage collection may also be an issue
11. S I N G L E T H R E A D E D
E V E N T D R I V E N
A S Y N C H R O N O U S
N O N - B L O C K I N G
What Jargons Mean
12. Single Threaded
New Node process does not start for every request
Only one code executes at a time
Everything else remains in the queue
No worry about different portions of code accessing the same
data structures at the same time
Delay at one place delays everything after that
Can not take advantage of multi-core CPU
Then how NodeJS is fast?
@akshaymathu
12
13. Non-blocking
There is only one process that is executing
If the process waits for something to complete, everything else
gets delayed
So the code has to be structured in a way that wait
for IO happens outside the main execution
@akshaymathu
13
14. Blocking Vs. Non-blocking
@akshaymathu
14
var a = db.query('SELECT * from huge_table’);
console.log('result a:’, a);
console.log(‘Doing something else’);
Blocking I/O
Non-Blocking I/O
db.query('SELECT * from huge_table’, function(res) {
console.log('result a:’, res);
});
console.log(‘Doing something else’);
15. Asynchronous
Not all code is executed in the same order it is
written
Node (and you) divide the code into small pieces and
fire them in parallel
Typically the code announces its state of execution
(or completion) via events
@akshaymathu
15
16. Event Driven
A code block gets into the queue of execution when
an event happens
It gets executed on its turn
Anyone can raise (or listen to) an event
System
Some library (module)
Your code
You have the choice (and ways) to attach a code
block to an event
Also known as event callbacks
@akshaymathu
16
18. ‘King and Servants’ Analogy… by Felix Geisendörfer
everything runs in parallel, except your code. To understand that,
imagine your code is the king, and node is his army of servants.
The day starts by one servant waking up the king and asking him if he
needs anything. The king gives the servant a list of tasks and goes back
to sleep a little longer. The servant now distributes those tasks among
his colleagues and they get to work.
Once a servant finishes a task, he lines up outside the kings quarter to
report. The king lets one servant in at a time, and listens to things he
reports. Sometimes the king will give the servant more tasks on the
way out.
Life is good, for the king's servants carry out all of his tasks in parallel,
but only report with one result at a time, so the king can focus.
@akshaymathu
18
20. D O T H E Y O C C U R O N S E R V E R A S W E L L ?
Events
21. Events we know…
@akshaymathu
21
The event familiar to us are
Click
Focus
Blur
Hover
These events are raised when user interacts with
DOM elements
But the DOM is not being rendered in NodeJS
Then what events are we talking about in NodeJS?
22. Node Events
@akshaymathu
22
The most common event that a web server uses is
request
Raised when a web request (url) hits the server
Other events:
When chunk of multipart data (file) is received
When all chunks of file are received
When system finishes reading a file
When data set is returned by a database query
…
You can define your own events using event emitter
23. Let’s Revise: JS Function Facts
@akshaymathu
23
Function is a block of a code that gets executed when
called
JS function may not have a name
Anonymous functions can be used
JS function accept any data type as argument
Function is a valid data type in JS
A function can be assigned to a variable
A function can be passed as an argument to another
function
A function can be defined inside another function
24. Event Callback
@akshaymathu
24
Because the system is single threaded
And we do not want to block it for I/O
We use asynchronous functions for getting work done
We depend on the events to tell when some work is
finished
And we want some code to execute when the event occurs
Asynchronous functions take a function as an
additional argument and call the function when the
event occurs
This function is known as callback function
25. Callback in Action
@akshaymathu
25
callback = function(res) {
console.log('result a:’, res);
};
db.query('SELECT * from huge_table’, callback);
Or
db.query('SELECT * from huge_table’, function(res) {
console.log('result a:’, res);
});
27. N O T H I N G B U T L I B R A R I E S
Node Modules
28. Available Modules
@akshaymathu
28
Modules are nothing but collections of useful
functions
Otherwise we call them libraries
Built-in modules come with NodeJS installation
http, tcp, url, dns, buffer, udp etc.
People create more modules, package and publish
them for others to use
less, coffee, express etc.
1000+ modules are available via npm
You can write your own custom module for
organizing your code better
29. Creating Custom Module
@akshaymathu
29
Write some useful code in a file
Some function(s) achieving a goal
Decide what should be available outside for others to
use
Public API of your module
Make the APIs available outside using exports object
my_api = function(){…};
exports.myApi = my_api;
30. Using Modules
@akshaymathu
30
‘require’ functions loads a module
Whatever has been exported becomes available with
‘require’ and can be assigned to a variable for later
use
var http = require(‘http’);
var custom = require(‘./my_api’);
custom.myApi();
32. A S I M P L E W E B S E R V E R
@akshaymathu
32
Let’s Program
33. Hello World
@akshaymathu
33
Just one line is needed to write to STDOUT
console.log(‘Hello World’)
Running the file with Node just works
node hello_world.js
35. Improving the Server
@akshaymathu
35
Running this server with Node starts the server
node server.js
The server always returns same string
Try any url, browser always says “Hello World”
Actually the server should respond content based on
URL
It should route the request to proper handler
Handler should return proper content
36. Organizing Code
@akshaymathu
36
Rather than writing everything in single file, it is a
good idea to divide the code into logical modules
Main startup file: index.js
Web server: server.js
URL Router: routes.js
Request Handler: requestHandlers.js
…
More files and directories will come as the code
grows
37. Initial Server Module
@akshaymathu
37
var http = require("http");
function start() {
function onRequest(request, response){
console.log("Request received.");
response.writeHead(200,
{"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
38. Initial Startup File
@akshaymathu
38
As server became a module and exposes a start
function, we need to
load server module
Call start function to start the server
var server = require("./server");
server.start();
Running the main file with now starts the server
node index.js
But it still returns ‘Hello world’ for all URLs
39. Let’s Revise: Parts of URL
https://sub.domain.com:8086/a/folder/file.html?key
=val&key=val2#some_place
Protocol
Sub-domain, Domain and TLD
Port
Path
File
Query string
Fragment
@akshaymathu
39
40. Server – Router Interaction
@akshaymathu
40
For routing the requests based on URL, the router
must know pathname of the requested URL
The URL can be read from the ‘request’ object available in
server module
So what should we pass to the router?
Request object
URL (Extract URL from request in server)
Pathname (Extract and parse URL in server)
??
If server need to call router, how router becomes
available to server?
42. Router Aware Server
@akshaymathu
42
var http = require("http");
var url = require("url");
function start(route) {
function onRequest(request, response){
var pathname =
url.parse(request.url).pathname;
route(pathname);
response.writeHead(200, "Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
}
exports.start = start;
43. Making Router Available to Server
@akshaymathu
43
Router is made available as an argument (dependency) to
server’s ‘start’ function
This is also known as dependency injection
var server = require("./server");
var router = require("./router");
server.start(router.route);
Router module is loaded in startup file and the route
function is passed at the time of starting server
Server then calls route function of the router with the
pathname
44. Adding Request Handlers
@akshaymathu
44
The actual work of creating response for a request
will be done by Request Handlers
We need to add these handlers to the server
The requestHandlers module will consist of a
function corresponding to each expected URL
At some place, we also need mapping between URL
and the request handler function
45. Initial Request Handlers
@akshaymathu
45
function start() {
console.log("Request for 'start’.");
return "Hello Start";
}
function upload() {
console.log("Request for 'upload.");
return "Hello Upload";
}
exports.start = start;
exports.upload = upload;
46. Including Handlers
@akshaymathu
46
var server = require("./server");
var router = require("./router");
var requestHandlers =
require("./requestHandlers");
var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
server.start(router.route, handle);
47. Change in Server
@akshaymathu
47
function start(route, handle) {
function onRequest(request, response) {
var pathname =
url.parse(request.url).pathname;
content = route(handle, pathname);
response.writeHead(200, {"Content-Type":
"text/plain"});
response.write(content);
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
48. Real Routing
@akshaymathu
48
function route(handle, pathname) {
console.log(”Routing request for " + pathname);
if (typeof handle[pathname] === 'function') {
return handle[pathname]();
} else {
console.log("No request handler found
for " + pathname);
}
}
exports.route = route;
51. What is wrong?
@akshaymathu
51
function start(route, handle) {
function onRequest(request, response) {
var pathname =
url.parse(request.url).pathname;
content = route(handle, pathname);
response.writeHead(200, {"Content-Type": "text/plain"});
response.write(content);
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
Blocking
Code
52. What are the problems?
@akshaymathu
52
The way ‘content’ is being collected and being
written to response, it forces to write blocking
synchronous code in handlers
Because handler has to return content when called
If you write asynchronous code in handler, the server
will always return response with no content
Because handler will return nothing and when callback will
return with the content, there will be no one to collect the
output
53. The Right Way
@akshaymathu
53
The content should be written into response object
when the content becomes available
So the response object should be made available to
request handlers
Response object is available in server
Server is not directly calling request handlers
So first, Response object will be passed to router
And then, Router will pass it to request handlers
54. Corrected Server
@akshaymathu
54
var http = require("http");
var url = require("url");
function start(route, handle) {
function onRequest(request, response) {
var pathname =
url.parse(request.url).pathname;
console.log("Request for " + pathname);
route(handle, pathname, response);
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
55. Corrected Router
@akshaymathu
55
function route(handle, pathname, response) {
console.log(”Routing request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response);
} else {
console.log("No handler found for " +
pathname);
response.writeHead(404, {"Content-Type":
"text/plain"});
response.write("404 Not found");
response.end();
}
}
exports.route = route;
56. Corrected Handlers
@akshaymathu
56
function start(response) {
db.query(”select * from huge_table”,
function (error, stdout, stderr) {
response.writeHead(200,
{"Content-Type": "text/plain"});
response.write(stdout);
response.end();
});
}
exports.start = start;
59. Summary
Node will require extra work and different thought
process
But it will pay off for it
Choose Node carefully only for the type of app it is
best suited
You may not need to write code at the lowest level we
discussed here
You may want to choose framework
@akshaymathu
59
60. MVC in Node
Express (Controller)
Mongoose (Model)
Jade (View)
More …
@akshaymathu
60