Discover VakinduPhilliam/JavaScript_Class

NodeJS Clean Architecture. Clean Architecture is an opinionated boilerplate for Node web APIs focused on separation of concerns and scalability with Uncle Bob Clean Architecture implementation. Features: > Union - Layered folder structure: code organization focused on codebase scalability. > Instant feedback and reload: use Nodemon to automatically reload the server after a file change when on development mode, makes the development faster and easier. > Scalable and easy to use web server. > Use Express for requests routing and middlewares. There are some essential middlewares for web APIs already setup, like body-parser, compression, and method-override. > Database integration: Mongoose, a MongoDB Database Connection, is already integrated; you just have to set the authentication configurations. > Prepared for testing: The test suite uses Mocha, Chai and is prepared to run unit, integration and functional tests right from the beginning. A FactoryGirl adapter for Mongo is setup to make your tests DRY as well, and the tests generate code coverage measurement with. You should read about the Chai plugins that are setup by default too. > Dependency injection: With Awilix, a practical dependency injection library, the code will not be coupled and it'll still be easy to resolve automatically the dependencies on the runtime and mock them during the tests. It's even possible inject dependencies on your controllers with the Awilix Express adapter. >Logging: The Log4js logger is highly pluggable, being able to append the messages to a file during the development and send them to a logging service when on production. Even the requests (through Morgan) and queries will be logged. > Linter: It's also setup with ESLint to make it easy to ensure a code styling and find code smells. How to use: Notice that the boilerplate comes with a small application for user management already; you can delete it with a npm script after you understand how the boilerplate works but please do the quick start first! 1. Clone the repository. 2. Setup the database on `config/database.js` (there's an example file there to be used with MongoDB). 3. Install the dependencies with `yarn`. 4. Create the development and test databases you have setup on `config/database.js` 5. Run the application in development mode with `npm run dev` 6. Access `http://localhost:3000/api/users` and you're ready to go! Compiled and presented by Vakindu Philliam.

NodeJS_Clean_Architecture

The following scripts are written to demonstrate how to compare sequences in Python using the ‘difflib’ module. ‘difflib’ contains a series of helpers for computing deltas. This module provides classes and functions for comparing sequences and pattern matching. It can be used for example, for comparing files, and can produce difference information in various formats, including HTML and context and unified diffs. class difflib.SequenceMatcher This is a flexible class for comparing pairs of sequences of any type, so long as the sequence elements are hashable. The basic algorithm predates, and is a little fancier than, an algorithm published in the late 1980’s by Ratcliff and Obershelp under the hyperbolic name “gestalt pattern matching.” The idea is to find the longest contiguous matching subsequence that contains no “junk” elements; these “junk” elements are ones that are uninteresting in some sense, such as blank lines or whitespace. (Handling junk is an extension to the Ratcliff and Obershelp algorithm.) The same idea is then applied recursively to the pieces of the sequences to the left and to the right of the matching subsequence. This does not yield minimal edit sequences, but does tend to yield matches that “look right” to people. Timing: The basic Ratcliff-Obershelp algorithm is cubic time in the worst case and quadratic time in the expected case. SequenceMatcher is quadratic time for the worst case and has expected-case behavior dependent in a complicated way on how many elements the sequences have in common; best case time is linear. Automatic junk heuristic: SequenceMatcher supports a heuristic that automatically treats certain sequence items as junk. The heuristic counts how many times each individual item appears in the sequence. If an item’s duplicates (after the first one) account for more than 1% of the sequence and the sequence is at least 200 items long, this item is marked as “popular” and is treated as junk for the purpose of sequence matching. This heuristic can be turned off by setting the autojunk argument to False when creating the SequenceMatcher. class difflib.Differ This is a class for comparing sequences of lines of text, and producing human-readable differences or deltas. Differ uses SequenceMatcher both to compare sequences of lines, and to compare sequences of characters within similar (near-matching) lines. Compiled and presented by Vakindu Philliam.

Pattern_Matching

Explore next generation concepts in Node.js RESTful API application development.

Node.js_REST

The following scripts are written to demonstrate the use of Python Coroutines and Tasks. Coroutines declared with async/await syntax is the preferred way of writing asyncio applications. To actually run a coroutine, asyncio provides three main mechanisms: > The asyncio.run() function to run the top-level entry point “main()” function. > Awaiting on a coroutine: An object is an awaitable object if it can be used in an await expression. Many asyncio APIs are designed to accept awaitables. > The asyncio.create_task() function to run coroutines concurrently as asyncio Tasks. There are three main types of awaitable objects: coroutines, Tasks, and Futures. Coroutines: Python coroutines are awaitables and therefore can be awaited from other coroutines. Tasks: Tasks are used to schedule coroutines concurrently. When a coroutine is wrapped into a Task with functions like asyncio.create_task() the coroutine is automatically scheduled to run soon: Futures: A Future is a special low-level awaitable object that represents an eventual result of an asynchronous operation. When a Future object is awaited it means that the coroutine will wait until the Future is resolved in some other place. Future objects in asyncio are needed to allow callback-based code to be used with async/await. Normally there is no need to create Future objects at the application level code. Future objects, sometimes exposed by libraries and some asyncio APIs, can be awaited: Compiled and presented by Vakindu Philliam.

Multiprocess_Coroutines

This series of scripts is written to demonstrate the various uses of Python Regular Expressions (Regex). The Python ‘re’ module is used to perform regular expression operations. This module provides regular expression matching operations similar to those found in Perl. Both patterns and strings to be searched can be Unicode strings (str) as well as 8-bit strings (bytes). However, Unicode strings and 8-bit strings cannot be mixed: that is, you cannot match a Unicode string with a byte pattern or vice-versa; similarly, when asking for a substitution, the replacement string must be of the same type as both the pattern and the search string. Regular expressions use the backslash character ('\') to indicate special forms or to allow special characters to be used without invoking their special meaning. This collides with Python’s usage of the same character for the same purpose in string literals; for example, to match a literal backslash, one might have to write '\\\\' as the pattern string, because the regular expression must be \\, and each backslash must be expressed as \\ inside a regular Python string literal. Compiled and presented by Vakindu Philliam.

Regex_Engine

Search and explore the best safari destinations on the planet.

safaridestinations

CSS

Python_Filesystem_Mechanics

The following scripts are written to demonstrate file handling and management modules in Python. The library modules explored include; LZMA: compression using the LZMA algorithm. This module provides classes and convenience functions for compressing and decompressing data using the LZMA compression algorithm. Also included is a file interface supporting the .xz and legacy .lzma file formats used by the xz utility, as well as raw compressed streams. The interface provided by this module is very similar to that of the bz2 module. However, note that LZMAFile is not thread-safe, unlike bz2.BZ2File, so if you need to use a single LZMAFile instance from multiple threads, it is necessary to protect it with a lock. GZIP: Support for gzip files. This module provides a simple interface to compress and decompress files just like the GNU programs gzip and gunzip would. The data compression is provided by the zlib module. The gzip module provides the GzipFile class, as well as the open(), compress() and decompress() convenience functions. The GzipFile class reads and writes gzip-format files, automatically compressing or decompressing the data so that it looks like an ordinary file object. Tarfile: read and write tar archive files. The tarfile module makes it possible to read and write tar archives, including those using gzip, bz2 and lzma compression. Use the zipfile module to read or write .zip files, or the higher-level functions in shutil. Plistlib: generate and parse Mac OS X .plist files. This module provides an interface for reading and writing the “property list” files used mainly by Mac OS X and supports both binary and XML plist files. The property list (.plist) file format is a simple serialization supporting basic object types, like dictionaries, lists, numbers and strings. Usually the top level object is a dictionary. To write out and to parse a plist file, use the dump() and load() functions. To work with plist data in bytes objects, use dumps() and loads(). Values can be strings, integers, floats, booleans, tuples, lists, dictionaries (but only with string keys), Data, bytes, bytesarray or datetime.datetime objects. Fnmatch: unix filename pattern matching. This module provides support for Unix shell-style wildcards, which are not the same as regular expressions. Glob: unix style pathname pattern expansion. The glob module finds all the pathnames matching a specified pattern according to the rules used by the Unix shell, although results are returned in arbitrary order. No tilde expansion is done, but *, ?, and character ranges expressed with [] will be correctly matched. This is done by using the os.scandir() and fnmatch.fnmatch() functions in concert, and not by actually invoking a subshell. Pathlib: object-oriented filesystem paths. This module offers classes representing filesystem paths with semantics appropriate for different operating systems. Path classes are divided between 'pure paths', which provide purely computational operations without I/O, and 'concrete paths', which inherit from pure paths but also provide I/O operations. Fileinput: iterate over lines from multiple input streams. This module implements a helper class and functions to quickly write a loop over standard input or a list of files. Filecmp: file and Directory Comparisons. The filecmp module defines functions to compare files and directories, with various optional time/correctness trade-offs. Tempfile: generate temporary files and directories. This module creates temporary files and directories. It works on all supported platforms. TemporaryFile, NamedTemporaryFile, TemporaryDirectory, and SpooledTemporaryFile are high-level interfaces which provide automatic cleanup and can be used as context managers. mkstemp() and mkdtemp() are lower-level functions which require manual cleanup. Compiled and presented by Vakindu Philliam.

The following scripts demonstrate the use of the Python module ‘configparser’ used for Configuration File Parsing. configparser — Configuration file parser. This module provides the ConfigParser class which implements a basic configuration language which provides a structure similar to what’s found in Microsoft Windows INI files. You can use this to write Python programs which can be customized by end users easily.

Python_Configuration_Parser

The following scripts are written to demonstrate basic Python cryptography and probability functions. Also illustrated is how to generate random numbers using Python’s random number generator functions. The ‘random’ Python module generates pseudo-random numbers. This module implements pseudo-random number generators for various distributions. For integers, there is uniform selection from a range. For sequences, there is uniform selection of a random element, a function to generate a random permutation of a list in-place, and a function for random sampling without replacement. On the real line, there are functions to compute uniform, normal (Gaussian), lognormal, negative exponential, gamma, and beta distributions. For generating distributions of angles, the von Mises distribution is available. Compiled and presented by Vakindu Philliam.

Python_Probability_Cryptography

The following scripts are written to demonstrate how to extend the Python Programming language with C and C++. To support extensions, the Python API (Application Programmers Interface) defines a set of functions, macros and variables that provide access to most aspects of the Python run-time system. The Python API is incorporated in a C source file by including the header "Python.h". The compilation of an extension module depends on its intended use as well as on your system setup. Note: The C extension interface is specific to CPython, and extension modules do not work on other Python implementations. In many cases, it is possible to avoid writing C extensions and preserve portability to other implementations. For example, if your use case is calling C library functions or system calls, you should consider using the ctypes module or the cffi library rather than writing custom C code. These modules let you write Python code to interface with C code and are more portable between implementations of Python than writing and compiling a C extension module. Compiled and presented by Vakindu Philliam.

CPython_Extension

Python_Crypt_Routine

The following scripts demonstrate the process of Python cryptography and hashing and how to use ‘Crypt’ and ‘hashlib’ module ‘Crypt’ - a function to check Unix passwords. This module implements an interface to the crypt(3) routine, which is a one-way hash function based upon a modified DES algorithm. Possible uses include storing hashed passwords so you can check passwords without storing the actual password, or attempting to crack Unix passwords with a dictionary. Notice that the behavior of this module depends on the actual implementation of the crypt(3) routine in the running system. Therefore, any extensions available on the current implementation will also be available on this module. ‘hashlib’ – a function module for generating secure hashes and message digests. This module implements a common interface to many different secure hash and message digest algorithms. Included are the FIPS secure hash algorithms SHA1, SHA224, SHA256, SHA384, and SHA512 (defined in FIPS 180-2) as well as RSA’s MD5 algorithm (defined in Internet RFC 1321). The terms “secure hash” and “message digest” are interchangeable. Older algorithms were called message digests. The modern term is secure hash. Also demonstrate is how to write Hash algorithms. Compiled and presented by Vakindu Philliam.

Javascript_Gravity_Game

JavaScript & Gravity

JQuery, PHP and CSS multiple photo upload.

JQuery_JS_PHP_Multiple_Upload

Exporting your Data as CSV, Excel (XLS), or XLSX in Python with Django.

Spreadsheet_Exports

Dig a well is a platform built to improve access to clean water in remote communities by highlighting places where new waterholes should be dug.

digawell

CSS

Socket_Programming

Sockets for client-server communication. The combination of sockets with INET makes talking to arbitrary machines on a global network unbelievably easy.

Explore Django's Low-level and high-level API for signing values with Python.

Cryptographic_Signatures

Spawning multiple concurrent processes in Python using subprocesses instead of threading.

Multiprocess_Parallelism

The Adam Blockchain Computer (Adam BC) is a decentralized blockchain based super computer.

Adam

The following scripts are written to demonstrate the Python Ctypes library. ‘ctypes’ is a foreign function library for Python. It provides C compatible data types, and allows calling functions in DLLs or shared libraries. It can be used to wrap these libraries in pure Python.

Python_Ctypes_Embedding

The following series of scripts is written to demonstrate the use of Python Numeric and Mathematical Modules. Written below is a description of its classes. numbers — Numeric abstract base classes. The numbers module (PEP 3141) defines a hierarchy of numeric abstract base classes which progressively define more operations. None of the types defined in this module can be instantiated. math — Mathematical functions. This module is always available. It provides access to the mathematical functions defined by the C standard. cmath — Mathematical functions for complex numbers. This module is always available. It provides access to mathematical functions for complex numbers. The functions in this module accept integers, floating-point numbers or complex numbers as arguments. decimal — Decimal fixed point and floating point arithmetic. The decimal module provides support for fast correctly-rounded decimal floating point arithmetic. It offers several advantages over the float datatype: random — Generate pseudo-random numbers This module implements pseudo-random number generators for various distributions. statistics — Mathematical statistics functions. This module provides functions for calculating mathematical statistics of numeric (Real-valued) data.

Python_Math_Functions

Python C/C++ Runtime API. The Application Programmer’s Interface to Python gives C and C++ programmers access to the Python interpreter at a variety of levels. There are two fundamentally different reasons for using the Python/C API. The first reason is to write extension modules for specific purposes; these are C modules that extend the Python interpreter. This is probably the most common use. The second reason is to use Python as a component in a larger application; this technique is generally referred to as embedding Python in an application. Compiled and presented by Vakindu Philliam.

CPython_Runtime_Interface

Python_XML_Processing

These scripts are written to explore the practice of processing XML documents using the xml.dom API (Application Programming Interface). The following scripts are explored; Python XML DOM Minidom. ‘xml.dom.minidom’ is a minimal DOM implementation. xml.dom.minidom is a minimal implementation of the Document Object Model interface, with an API similar to that in other languages. It is intended to be simpler than the full DOM and also significantly smaller. Users who are not already proficient with the DOM should consider using the xml.etree.ElementTree module for their XML processing instead. Python XHTML Parser. ‘html.parser’ is a simple HTML and XHTML parser. This module defines a class HTMLParser which serves as the basis for parsing text files formatted in HTML (HyperText Mark-up Language) and XHTML. Python XML Parsers Expat. ‘xml.parsers.expat’ is a fast XML parsing using Expat. Warning: The pyexpat module is not secure against maliciously constructed data. If you need to parse untrusted or unauthenticated data see XML vulnerabilities. The xml.parsers.expat module is a Python interface to the Expat non-validating XML parser. The module provides a single extension type, xmlparser, that represents the current state of an XML parser. After an xmlparser object has been created, various attributes of the object can be set to handler functions. When an XML document is then fed to the parser, the handler functions are called for the character data and markup in the XML document. Python XML Pulldom. ‘xml.dom.pulldom’ is a support for building partial DOM trees. The xml.dom.pulldom module provides a “pull parser” which can also be asked to produce DOM-accessible fragments of the document where necessary. The basic concept involves pulling “events” from a stream of incoming XML and processing them. In contrast to SAX which also employs an event-driven processing model together with callbacks, the user of a pull parser is responsible for explicitly pulling events from the stream, looping over those events until either processing is finished or an error condition occurs. Python XML Etree Element Tree. ‘xml.etree.ElementTree’ is the the ElementTree XML API. The xml.etree.ElementTree module implements a simple and efficient API for parsing and creating XML data.

These scripts are written to demonstrate the process of Python Memory Allocation, Partitioning and Mapping. The Python ‘tracemalloc’ module is used to trace memory allocations. The tracemalloc module is a debug tool to trace memory blocks allocated by Python. It provides the following information: > Traceback where an object was allocated. > Statistics on allocated memory blocks per filename and per line number: total size, number and average size of allocated memory blocks. > Compute the differences between two snapshots to detect memory leaks. To trace most memory blocks allocated by Python, the module should be started as early as possible by setting the PYTHONTRACEMALLOC environment variable to 1, or by using -X tracemalloc command line option. The tracemalloc.start() function can be called at runtime to start tracing Python memory allocations. Compiled and presented by Vakindu Philliam.

Python_Memory_Architecture

This series of Python scripts explores the crucial practice of fetching internet resources using the ‘urllib’ module. Urllib: Fetching Internet Resources Using The urllib Package. urllib.request is a Python module for fetching URLs (Uniform Resource Locators). It offers a very simple interface, in the form of the urlopen function. This is capable of fetching URLs using a variety of different protocols. It also offers a slightly more complex interface for handling common situations - like basic authentication, cookies, proxies and so on. These are provided by objects called handlers and openers. urllib.request supports fetching URLs for many “URL schemes” (identified by the string before the ":" in URL - for example "ftp" is the URL scheme of "ftp://python.org/") using their associated network protocols (e.g. FTP, HTTP). This tutorial focuses on the most common case, HTTP. For straightforward situations urlopen is very easy to use. But as soon as you encounter errors or non-trivial cases when opening HTTP URLs, you will need some understanding of the HyperText Transfer Protocol. The most comprehensive and authoritative reference to HTTP is RFC 2616. This is a technical document and not intended to be easy to read. This HOWTO aims to illustrate using urllib, with enough detail about HTTP to help you through. It is not intended to replace the urllib.request docs, but is supplementary to them. Also explored is the Python ‘ftplib’ module, used as an FTP protocol client. This module defines the class FTP and a few related items. The FTP class implements the client side of the FTP protocol. You can use this to write Python programs that perform a variety of automated FTP jobs, such as mirroring other FTP servers. It is also used by the module urllib.request to handle URLs that use FTP.

Python_Urllib_Components

The following scripts demonstrate the implementations of various Python modules. The modules explored include; bisect : Array bisection algorithm. This module provides support for maintaining a list in sorted order without having to sort the list after each insertion. For long lists of items with expensive comparison operations, this can be an improvement over the more common approach. The module is called bisect because it uses a basic bisection algorithm to do its work. The bisect() function can be useful for numeric table lookups. This example uses bisect() to look up a letter grade for an exam score (say) based on a set of ordered numeric breakpoints: 90 and up is an ‘A’, 80 to 89 is a ‘B’, and so on: shlex: Simple lexical analysis. The shlex class makes it easy to write lexical analyzers for simple syntaxes resembling that of the Unix shell. This will often be useful for writing minilanguages, (for example, in run control files for Python applications) or for parsing quoted strings. readline: GNU readline interface. The readline module defines a number of functions to facilitate completion and reading/writing of history files from the Python interpreter. This module can be used directly, or via the rlcompleter module, which supports completion of Python identifiers at the interactive prompt. Settings made using this module affect the behaviour of both the interpreter’s interactive prompt and the prompts offered by the built-in input() function. operator: Standard operators as functions. The operator module exports a set of efficient functions corresponding to the intrinsic operators of Python. For example, operator.add(x, y) is equivalent to the expression x+y. Many function names are those used for special methods, without the double underscores. For backward compatibility, many of these have a variant with the double underscores kept. The variants without the double underscores are preferred for clarity. The functions fall into categories that perform object comparisons, logical operations, mathematical operations and sequence operations. stat: Interpreting stat() results. The stat module defines constants and functions for interpreting the results of os.stat(), os.fstat() and os.lstat() (if they exist). Normally, you would use the os.path.is*() functions for testing the type of a file; the functions here are useful when you are doing multiple tests of the same file and wish to avoid the overhead of the stat() system call for each test. These are also useful when checking for information about a file that isn’t handled by os.path, like the tests for block and character devices. Compiled and presented by Vakindu Philliam.

Python_Lexical_Dialect

WebRTC Realtime Videocall Engine. WebRTC enables real-time peer-to-peer video communication. Running WebRTC locally requires Google App Engine SDK for Python. If using Google Cloud Engine VM's for Collider, Change `WSS_INSTANCE_HOST_KEY`, `WSS_INSTANCE_NAME_KEY` and `WSS_INSTANCE_ZONE_KEY` to corresponding values for your VM instances which can be found in the Google Cloud Engine management console. Else if using other VM hosting solution, Change `WSS_INSTANCE_HOST_KEY` to the hostname and port Collider is listening too, e.g. localhost:8089 or otherHost:443. REMEMBER: > Enabling Local Logging; Note that logging is automatically enabled when running on Google App Engine using an implicit service account. By default, logging to a BigQuery from the development server is disabled. Log information is presented on the console. Unless you are modifying the analytics API you will not need to enable remote logging. Logging to BigQuery when running LOCALLY requires a `secrets.json` containing Service Account credentials to a Google Developer project where BigQuery is enabled. > DO NOT COMMIT `secrets.json` TO THE REPOSITORY. To generate a `secrets.json` file in the Google Developers Console for your project: 1. Go to the project page. 2. Under *APIs & auth* select *Credentials*. 3. Confirm a *Service Account* already exists or create it by selecting *Create new Client ID*. 4. Select *Generate new JSON key* from the *Service Account* area to create and download JSON credentials. 5. Rename the downloaded file to `secrets.json` and place in the directory containing `analytics.py`.

WebRTC_Realtime_Videocall_Engine

The following scripts explore the Python ‘weakref’ (Weak references) module. The weakref module allows the Python programmer to create weak references to objects. In the following, the term referent means the object which is referred to by a weak reference. A weak reference to an object is not enough to keep the object alive: when the only remaining references to a referent are weak references, garbage collection is free to destroy the referent and reuse its memory for something else. However, until the object is actually destroyed the weak reference may return the object even if there are no strong references to it. A primary use for weak references is to implement caches or mappings holding large objects, where it’s desired that a large object not be kept alive solely because it appears in a cache or mapping. For example, if you have a number of large binary image objects, you may wish to associate a name with each. If you used a Python dictionary to map names to images, or images to names, the image objects would remain alive just because they appeared as values or keys in the dictionaries. The WeakKeyDictionary and WeakValueDictionary classes supplied by the weakref module are an alternative, using weak references to construct mappings that don’t keep objects alive solely because they appear in the mapping objects. If, for example, an image object is a value in a WeakValueDictionary, then when the last remaining references to that image object are the weak references held by weak mappings, garbage collection can reclaim the object, and its corresponding entries in weak mappings are simply deleted. WeakKeyDictionary and WeakValueDictionary use weak references in their implementation, setting up callback functions on the weak references that notify the weak dictionaries when a key or value has been reclaimed by garbage collection. WeakSet implements the set interface, but keeps weak references to its elements, just like a WeakKeyDictionary does. finalize provides a straight forward way to register a cleanup function to be called when an object is garbage collected. This is simpler to use than setting up a callback function on a raw weak reference, since the module automatically ensures that the finalizer remains alive until the object is collected. Most programs should find that using one of these weak container types or finalize is all they need – it’s not usually necessary to create your own weak references directly. The low-level machinery is exposed by the weakref module for the benefit of advanced uses. Not all objects can be weakly referenced; those objects which can include class instances, functions written in Python (but not in C), instance methods, sets, frozensets, some file objects, generators, type objects, sockets, arrays, deques, regular expression pattern objects, and code objects.

Python_Weakref_Caching

Backend Python/Django custom service area polygon.

Django_Custom_Polygon

Javascript_Snow_Fall_Engine

Snow fall in JavaScript.

JavaScript examples to demonstrate the use of the JS Prototype Chain.

VakinduPhilliam

JavaScript_Prototype_Chain

Validating user input using Regex operators

C_Regex_Validation

Java_Radix_Sort

Sorting an array using Radix Sort in java.

Botpress

Creating bots.

JavaScript examples to demonstrate the process of creating simple Animations using JS Animation Frames.

JavaScript_Draw_Animation

PHP examples on how to identify the classification of integer natural numbers.

PHP_Numerical_Classification

Least Recently Used Page implementation in JavaScript.

JavaScript_LRU_Algorithm

Identifying Hashtags in text using C/C++.

C_Hashtag_Identifier

Electron_API

ElectronJS API.

Bit masking using C & C++.

C_Directory_Management

Android_Java_Memory_Management

Managing memory used by an App while in use.

Using JavaScript, jQuery and Ajax to count word frequencies or number occurrences in a JSON text file.

JavaScript_JSON_Frequency_Mapping

C++ examples to demonstrate the process of mapping out the frequency occurrences of words and numbers in a given text or string.

CPP_Frequency_Map

C++

serverless-engineering

DynamoDB RESTful API with Pagination and a Serverless Architecture.

JavaScript examples to demonstrate the process of generating random numbers from a set of given values.

JavaScript_Random_Number_Generator

The following scripts are written to demonstrate Python Internet communication protocols. The following modules are explored. ‘mailbox’: manipulate mailboxes in various formats. This module defines two classes, Mailbox and Message, for accessing and manipulating on-disk mailboxes and the messages they contain. Mailbox offers a dictionary-like mapping from keys to messages. Message extends the email.message module’s Message class with format-specific state and behavior. Supported mailbox formats are Maildir, mbox, MH, Babyl, and MMDF. ‘smtplib’: SMTP protocol client. The smtplib module defines an SMTP client session object that can be used to send mail to any Internet machine with an SMTP or ESMTP listener daemon. ‘poplib’: POP3 protocol client. This module defines a class, POP3, which encapsulates a connection to a POP3 server and implements the protocol as defined in RFC 1939. The POP3 class supports both the minimal and optional command sets from RFC 1939. The POP3 class also supports the STLS command introduced in RFC 2595 to enable encrypted communication on an already established connection. Additionally, this module provides a class POP3_SSL, which provides support for connecting to POP3 servers that use SSL as an underlying protocol layer. ‘imaplib’: IMAP4 protocol client. This module defines three classes, IMAP4, IMAP4_SSL and IMAP4_stream, which encapsulate a connection to an IMAP4 server and implement a large subset of the IMAP4rev1 client protocol as defined in RFC 2060. It is backward compatible with IMAP4 (RFC 1730) servers, but note that the STATUS command is not supported in IMAP4. ‘nntplib’: NNTP protocol client. This module defines the class NNTP which implements the client side of the Network News Transfer Protocol. It can be used to implement a news reader or poster, or automated news processors. It is compatible with RFC 3977 as well as the older RFC 977 and RFC 2980. Compiled and presented by Vakindu Philliam.

Python_Connection_Protocols

Iterating through a JSON File. Implementation in JavaScript using JQuery and Ajax.

JavaScript_JSON_File_Iteration

JavaScript_JQuery_Date-_Picker

JavaScript Date Picker

Validating user input using Regex in PHP.

PHP_Regex_Validation

JavaScript examples to demonstrate advanced methods of playing with string data.

JavaScript_String_Handling

Tweet mining using Python.

Python_Tweet_Mining

Using JavaScript to Sort the elements of an array and return the largest 10 elements.

JavaScript_Top10_Number_Analysis

Java program examples to demonstrate the process of using regular expressions (Regex) in Java programming.

Java_Regex_Engine

This series of scripts is written to demonstrate the process of utilizing Python Class and Instance Variables and Python Class Object properties.

Python_Class_Semantics

Geolocation Polygons API.

geoapi

Asante AI is an AI powered safari recommendation engine for African travel destinations.

AsanteAI

EJS

C_Word_Frequencies

Counting words and letters in a text.

JavaScript_JSON_Email_Hunt

Identifying all emails in a JSON file using JavaScript, JQuery and Ajax.

Node.js and MCV (Model-View-Controller) pairing.

NodeJS_MVC

This series of Python scripts is written to demonstrate the process of creating a networking system. Basic functionalities include server-client communication and TCP networking protocols.

Python_Network_Architecture

This series of Python scripts is written to demonstrate the process of handling data contained inside a nested matrix. Included is the use of the Python Zip ( ) function.

Python_Nested_Matrix

JavaScript examples to demonstrate the various AddEventListener() function methods and their applications. Compiled and presented by Vakindu Philliam.

JavaScript_AddEventListener

JavaScript examples to demonstrate the process of creating a simple clock timer using JS Animation Frames.

JavaScript_Clock_Timer

C++ examples to demonstrate the various processes of handling file directories.

CPP_Directory_Algorithms

C++

JavaScript_Partition_Redistribution

JavaScript examples to demonstrate advanced methods of playing with the elements of an arrays.

Convert a user input into a JSON file using JavaScript.

JavaScript_Form_to_JSON

NodeJS example on how to upload files using Redux and ExpressJS.

NodeJS_Redux_File_Upload_Architecture

Implementing binary stream protocols for serializing and de-serializing a Python object structure.

Hierachy_Serialization

JavaScript Nested functions.

Javascript_Nested_Functions

Javascript_Block_Bounce_Game

Javascript game

This series of Python scripts is written to demonstrate some basic aspects of Data Science. Data Science is a field in computer science that is dedicated to analyzing patterns in raw data using techniques like artificial intelligence (AI), Machine Learning (ML), mathematical functions, and statistical algorithms.

Python_Data_Science

JavaScript examples to demonstrate the process of identifying specific data in a text.

JavaScript_Data_Parsing

Validating user inputs in JavaScript using Regex.

JavaScript_Regex_Validation

JavaScript functions that take in an array of elements and returns the top k elements as specified by the user.

JavaScript_TopK_Number_Analysis

Demonstrating the various JavaScript algorithm implementations.

Javascript_Algorithms

Advanced JavaScript functions to demonstrate the use of Splice method function for sorting the elements of an array.

JavaScript_Advanced_Splice

Building Animations using JavaScript.

JavaScript_Animation

Validating user input using Regex in Java.

Java_Regex_Validation

Caterpillar Zombie is an invasion game where players defend their fruits from invading zombie caterpillars.

CaterpillarZombie

EJS

Java_Hashtag_Identifier

Identifying Hashtags in Text using Java.

This series of Python scripts is written to demonstrate the process of creating an email communication system. Basic functionalities include sending and receiving an email and attaching files like photos.

Python_Email_Parser

Git Max is an AI web app built to ease the detection of the most critical pull-requests on a software project while filtering out less important pull-requests, profanity and abuse.

gitmax

Bitfull is an AI powered web app that uses Machine Learning to determine the most relevant Bitbucket project issues and pull requests that require the developer's urgent attention.

bitfull

Image Max is an AI web app built to ease the detection of the most critical pull-requests in a software project using Machine Learning while filtering out less important pull-requests, profanity and abuse.

imagemax

Financial Management tool to calculate APY.

Finance_APY

JavaScript examples to demonstrate the process of handling script and user events.

JavaScript_Event_Handling

Merge Sort, Bubble Sort, Insertion Sort.

JavaScript_Sorting_Algorithms

JavaScript examples to demonstrate the process of creating stripe image Animations.

JavaScript_Sprite_Strip_Animation

This series of scripts is written to demonstrate the process of Python Signal Handling. The 'signal' module sets handlers for asynchronous events. This module provides mechanisms to use signal handlers in Python. The signal.signal() function allows defining custom handlers to be executed when a signal is received. A small number of default handlers are installed: SIGPIPE is ignored (so write errors on pipes and sockets can be reported as ordinary Python exceptions) and SIGINT is translated into a KeyboardInterrupt exception. A handler for a particular signal, once set, remains installed until it is explicitly reset (Python emulates the BSD style interface regardless of the underlying implementation), with the exception of the handler for SIGCHLD, which follows the underlying implementation.

Python_Signal_Pipeline

Lisk Blockchain SDK (Cloned).

Blockchain_SDK

Fundamental concepts in modern video game design and development.

Game_Development

JSON Database implementation in JavaScript using JQuery and Ajax.

JavaScript_JSON_Database

This series of scripts is written to demonstrate the uses of various Python Library Modules. Explored Modules include; Bisect, CL Arguments, Collections, Delimiter, Logging, Shutil, Statistics, Mathematics, Decimal.

Python_Library_Modules

JavaScript_Multiple_Photo_Upload

Multiple photo upload.

JavaScript examples to demonstrate the use of the JS Call method function.

JavaScript_Call_Function

JavaScript CSS star rating system.

JavaScript_JQuery_PHP_Star_Rating

Hack

Python_Data_Mapping

This series of scripts is written to explore the use of Python Data storage and Mapping structures. Demonstrations include the use of Lists, Tuples, Sequences, Sets, Dictionaries, etc.

An app that allows users to make real-time video calls to friends.

100

NodeJS_ReactJS_Videocall