• Stars
    star
    1
  • Language
    JavaScript
  • Created almost 6 years ago
  • Updated almost 6 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Merge Sort, Bubble Sort, Insertion Sort.

More Repositories

1

Node.js_Blockchain

Building a Blockchain peer-to-peer network using Node.js and Socket.io.
JavaScript
9
star
2

NodeJS_Clean_Architecture

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.
JavaScript
9
star
3

Pattern_Matching

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.
Python
8
star
4

Node.js_REST

Explore next generation concepts in Node.js RESTful API application development.
JavaScript
6
star
5

Multiprocess_Coroutines

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.
Python
4
star
6

Regex_Engine

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.
Python
4
star
7

safaridestinations

Search and explore the best safari destinations on the planet.
CSS
3
star
8

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.
Python
3
star
9

Python_Configuration_Parser

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
3
star
10

Python_Probability_Cryptography

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
3
star
11

CPython_Extension

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.
C
3
star
12

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.
Python
3
star
13

Javascript_Gravity_Game

JavaScript & Gravity
HTML
2
star
14

JQuery_JS_PHP_Multiple_Upload

JQuery, PHP and CSS multiple photo upload.
PHP
2
star
15

Spreadsheet_Exports

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

digawell

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.
CSS
2
star
17

Socket_Programming

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

Cryptographic_Signatures

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

Multiprocess_Parallelism

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

Adam

The Adam Blockchain Computer (Adam BC) is a decentralized blockchain based super computer.
JavaScript
2
star
21

Python_Ctypes_Embedding

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
2
star
22

Python_Math_Functions

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
2
star
23

CPython_Runtime_Interface

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.
C
2
star
24

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.
Python
2
star
25

Python_Memory_Architecture

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
2
star
26

Python_Urllib_Components

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
2
star
27

Python_Lexical_Dialect

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
2
star
28

WebRTC_Realtime_Videocall_Engine

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`.
JavaScript
2
star
29

Python_Weakref_Caching

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
2
star
30

Django_Custom_Polygon

Backend Python/Django custom service area polygon.
Python
1
star
31

Javascript_Snow_Fall_Engine

Snow fall in JavaScript.
HTML
1
star
32

VakinduPhilliam

1
star
33

JavaScript_Prototype_Chain

JavaScript examples to demonstrate the use of the JS Prototype Chain.
JavaScript
1
star
34

C_Regex_Validation

Validating user input using Regex operators
C
1
star
35

Java_Radix_Sort

Sorting an array using Radix Sort in java.
Java
1
star
36

Botpress

Creating bots.
JavaScript
1
star
37

JavaScript_Draw_Animation

JavaScript examples to demonstrate the process of creating simple Animations using JS Animation Frames.
HTML
1
star
38

PHP_Numerical_Classification

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

JavaScript_LRU_Algorithm

Least Recently Used Page implementation in JavaScript.
JavaScript
1
star
40

C_Hashtag_Identifier

Identifying Hashtags in text using C/C++.
C
1
star
41

Electron_API

ElectronJS API.
HTML
1
star
42

C_Directory_Management

Bit masking using C & C++.
C
1
star
43

Android_Java_Memory_Management

Managing memory used by an App while in use.
Java
1
star
44

JavaScript_JSON_Frequency_Mapping

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

CPP_Frequency_Map

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

serverless-engineering

DynamoDB RESTful API with Pagination and a Serverless Architecture.
JavaScript
1
star
47

JavaScript_Random_Number_Generator

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

Python_Connection_Protocols

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
1
star
49

JavaScript_JSON_File_Iteration

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

JavaScript_JQuery_Date-_Picker

JavaScript Date Picker
HTML
1
star
51

PHP_Regex_Validation

Validating user input using Regex in PHP.
PHP
1
star
52

JavaScript_String_Handling

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

Python_Tweet_Mining

Tweet mining using Python.
Python
1
star
54

JavaScript_Top10_Number_Analysis

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

JavaScript_Class_Syntax

JavaScript examples to demonstrate the use of the JS Class function method.
JavaScript
1
star
56

Java_Regex_Engine

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

Python_Class_Semantics

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

geoapi

Geolocation Polygons API.
Python
1
star
59

AsanteAI

Asante AI is an AI powered safari recommendation engine for African travel destinations.
EJS
1
star
60

C_Word_Frequencies

Counting words and letters in a text.
C
1
star
61

JavaScript_JSON_Email_Hunt

Identifying all emails in a JSON file using JavaScript, JQuery and Ajax.
HTML
1
star
62

NodeJS_MVC

Node.js and MCV (Model-View-Controller) pairing.
HTML
1
star
63

Python_Network_Architecture

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
1
star
64

Python_Nested_Matrix

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
1
star
65

JavaScript_AddEventListener

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

JavaScript_Clock_Timer

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

CPP_Directory_Algorithms

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

JavaScript_Partition_Redistribution

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

JavaScript_Form_to_JSON

Convert a user input into a JSON file using JavaScript.
HTML
1
star
70

NodeJS_Redux_File_Upload_Architecture

NodeJS example on how to upload files using Redux and ExpressJS.
JavaScript
1
star
71

Hierachy_Serialization

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

Javascript_Nested_Functions

JavaScript Nested functions.
HTML
1
star
73

Javascript_Block_Bounce_Game

Javascript game
HTML
1
star
74

Python_Data_Science

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
1
star
75

JavaScript_Data_Parsing

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

JavaScript_Regex_Validation

Validating user inputs in JavaScript using Regex.
JavaScript
1
star
77

JavaScript_TopK_Number_Analysis

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

Javascript_Algorithms

Demonstrating the various JavaScript algorithm implementations.
JavaScript
1
star
79

JavaScript_Advanced_Splice

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

JavaScript_Animation

Building Animations using JavaScript.
JavaScript
1
star
81

Java_Regex_Validation

Validating user input using Regex in Java.
Java
1
star
82

CaterpillarZombie

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

Java_Hashtag_Identifier

Identifying Hashtags in Text using Java.
Java
1
star
84

Python_Email_Parser

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
1
star
85

gitmax

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.
JavaScript
1
star
86

bitfull

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.
JavaScript
1
star
87

imagemax

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.
JavaScript
1
star
88

Finance_APY

Financial Management tool to calculate APY.
JavaScript
1
star
89

JavaScript_Event_Handling

JavaScript examples to demonstrate the process of handling script and user events.
HTML
1
star
90

JavaScript_Sprite_Strip_Animation

JavaScript examples to demonstrate the process of creating stripe image Animations.
HTML
1
star
91

Python_Signal_Pipeline

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
1
star
92

Blockchain_SDK

Lisk Blockchain SDK (Cloned).
JavaScript
1
star
93

Game_Development

Fundamental concepts in modern video game design and development.
HTML
1
star
94

JavaScript_JSON_Database

JSON Database implementation in JavaScript using JQuery and Ajax.
JavaScript
1
star
95

Python_Library_Modules

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
1
star
96

JavaScript_Multiple_Photo_Upload

Multiple photo upload.
PHP
1
star
97

JavaScript_Call_Function

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

JavaScript_JQuery_PHP_Star_Rating

JavaScript CSS star rating system.
Hack
1
star
99

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.
Python
1
star
100

NodeJS_ReactJS_Videocall

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