• Introduction
• Ilustrations
• Structure
• Technologies
• Setup
• Learn More

This is a storybook components library based on Tailwind. The main idea of this repo is to be a custom components backup idealize to be short and simple and integrate with your react app. We based the design structure in Atomic Design, which has an more condensed way to organize components. But we are not here to explain what Atomic Design is, but how it can improve the way you work with components.

This is where comes the illustrations

Do you want to contribute with us? Check this rules how to help us 🙂

• How to Contribute?

├── .storybook
├── docs
│   ├── contributing.md
│   ├── issue_templates.md
│   └── pull_requeste_template.md
├── public
├── src
│   ├── assets
│   │   ├── img
│   │   └──svg
│   ├── components
│   │   ├── atoms
│   │   │   ├── Button
│   │   │   ├── Checkbox
│   │   │   ├── Input
│   │   │   └── Text
│   │   ├── documentation
│   │   ├── molecules
│   │   │   ├── Card
│   │   │   └── Header
│   │   ├── organisms
│   │   │   └── PageStatic
│   │   └── templates
│   └── util

This is the project’s structure, here you can see the most important directories like:

• Atoms: in this section you can find isolate elements, like tags(buttons, inputs and checkbox);
• Molecules: in this section you will find the combination of elements inside of another element, like( cards and headers);
• Organisms: this section contain the combination of all previously elements.

You also will find the documentation necessary to colaborate with this project.

Project is created with:

• React version: 16.13
• ReactDOM version: 16.13
• Tailwind CSS version: 1.7
• Storybook version: 6.0
• Babel version: 8.1
• TypeScript version: 3.7

To run this project, install it locally using YARN:

$ yarn install or yarn
$ yarn storybook

or NPM:

$ npm install or npm i
$ npm run storybook

You can learn more in the Our wiki project progress.

| | | |

1. Overview
2. Module Description – What the module does and why it is useful
3. Setup – The basics of getting started with facter_cacheable
   • What facter_cacheable affects
   • Setup requirements
   • Beginning with facter_cacheable
4. Usage – Configuration options and additional functionality
5. Reference – An under-the-hood peek at what the module is doing and how
6. Limitations – OS compatibility, etc.
7. Development – Guide for contributing to the module

facter_cacheable implements a Puppet feature for Facter that caches fact values for a given time.

The features are inspired by the Puppet Blog on Facter from 2010.

This does not always work correctly with Puppet Enterprise 2016. PE purges pugin-synced facts directories on each run. This removes fact files Puppet’s agent thinks came from custom facts.

As mentioned in many getting started with Puppet guides, including some by Puppet Labs, caching a fact can be useful. A well-maintained cache can:

• reduce frequency of expensive calls
• store values reachable outside of Puppet agent runs
• explicitly control schedule of fact refreshing

There is limited planned support in Facter 2.0 and later for controlling some caching of Puppet facts. Personally this developer has never seen issues with it in the wild.

No, this is not yet-another-varnish module either.

Deploys a feature, facter_cacheable, which is usable for custom facts written by Puppet developers.

caching using this module requires at lest Ruby 2.3 and Puppet 4.7. Older releases cannot even run the test harness anymore.

PluginSync must be enabled on at least one Puppet agent run to deploy the module.

This module accepts no customization. The facter\_cache() call takes options for:

• the value to cache
• a time-to-live(ttl)
• an optional location to store the cache in.

If the directories containing the cache files do not exist, the module will attempt to create them.

To cache a value use cache:

require 'facter/util/facter_cacheable'
Facter::Util::FacterCacheable.cache(
  :fact_name_symbol,
  some_value,
  optional_cache_file
  )

To return a cached value use cached?:

require 'facter/util/facter_cacheable'
Facter::Util::FacterCacheable.cached?(
  :fact_name_symbol,
  ttl_in_seconds,
  optional_cache_file)

Complete Example

#
# my_module/lib/facter/my_custom_fact.rb
#
require 'facter'
require 'puppet/util/facter_cachable'

Facter.add(:my_custom_fact) do
  confine do
    Puppet.features.facter_cacheable?
  end
  setcode do
    # 24 * 3600 = 1 day of seconds
    cache = Facter::Util::FacterCacheable.cached?(:my_custom_fact, 24 * 3600)
    if ! cache
      my_value = some_expensive_operation()
      # store the value for later
      Facter::Util::FacterCacheable.cache(:my_custom_fact, my_value)
      # return the expensive value
      my_value
    else
      # return the cached value (this may need processing)
      cache
    end
  end
end

It is not required but encouraged to keep the name of the cache and fact the same. Although with all Ruby programming sanity is optional as it having documentation.

YAML stored values may appear as arrays or string-indexed hashes depending on the version of Puppet and Facter involved. Unpacking those is left as an exercise for the reader.

To test code that uses Facter_cacheable you will have to resort to a little used method for stubbing objects.

In your Facter fact guard against import of the module. Import will fail if you do not have it deployed to the Puppet environment on which the tests are running.

Note: even the rSpec setup will not properly install this utility for testing.

begin
    require 'facter/util/facter_cacheable'
  rescue LoadError => e
    Facter.debug("#{e.backtrace[0]}: #{$!}.")
end
# regular fact like the complete example above

In the rSpec Facter tests, normally some kind of function test on Facter.value(), setup a harness which can check for invocation of the cache functions.

context 'test caching' do
  let(:fake_class) { Class.new }
  before :each do
    allow(File).to receive(:exist?).and_call_original
    allow(Puppet.features).to receive(:facter_cacheable?) { true }
    Facter.clear
  end
  it 'should return and save a computed value with an empty cache' do
    stub_const("Facter::Util::FacterCacheable", fake_class)
    expect(Facter::Util::FacterCacheable).to receive(:cached?).with(
    :my_fact, 24 * 3600) { nil }
    expect(Facter::Util::Resolution).to receive(:exec).with(
    'some special comand') { mydata }
    expect(Facter::Util::FacterCacheable).to receive(:cache).with(
      :my_fact, mydata)
    expect(Facter.value(:my_fact).to eq(mydata)
  end
  it 'should return a cached value with a full cache' do
    stub_const("Facter::Util::FacterCacheable", fake_class)
    expect(Facter::Util::FacterCacheable).to receive(:cached?).with(
    :my_fact, 24 * 3600) { mydata }
    expect(mod).to_not receive(:my_fact)
    expect(Facter.value(:my_fact)).to eq(mydata)
  end
end

The key parts are the :fake_class and the stub_const() calls. These setup a kind of double that can be used by rSpec to hook into the Facter context.

• Facter Part 3: Caching and TTL
• Caching External Facts
• Puppet Cookbook: Deploying Custom Facts
• mcollective in puppet-modules
• Only two hard things in Computer Science

Supports F/OSS Puppet 4.7.0+. Tested on AIX, recent vintage Solaris, SuSE, RedHat and RedHat-derivatives.

Does not support Puppet Enterprise due to the cached value wipe on each run.

Don’t be surprised if is works elsewhere, too. Or if it sets your house on fire.

The name of this module, facter_cacheable, was chosen to not conflict with other existing implementations such as the Facter::Util::Cacheable support in early implementations of waveclaw/subscription_manager.

Please see CONTRIBUTING for advice on contributions.

This project’s goal is to allow users to emulate all of the features of OCPP (both 1.6 & 2.0.1) in order to allow easier testing and speed up local development, here is an overview of what has been implemented in the project so far

• Core (Done)
• Firmware Management (Done)
• Local Auth List Management (Done)
• Reservation (Not Done)
• Smart Charging (Semi Done)
• Remote Trigger (Done)

• Currently under development, the OCPP 2.0.1 version is not yet fully implemented, but we’re working on it.

If you’re using Intellij IDEA, you can just run one of the two configurations that are saved in the .run folder

• Run V16 for OCPP 1.6
• Run V201 for OCPP 2.0.1

If you’re just using the terminal, you can run the following command:

OCPP 1.6

./gradlew run v16:run

OCPP 2.0.1

./gradlew run v201:run

Clicking the icon gives access to “message interception”. The primary purpose is to have a high degree of control over which messages are sent and received by the charge point. That way it is possible to replicate potentially buggy behavior or custom implementations in a one-off manner without needing to change the actual programming of the charge point. For “normal operation” of the charge point the standard interface should be sufficient.

Also note that the message interception functions are not hooked up to the internal machinery of the charge point. For example, sending a StopTransaction message will not actually change the state of an ongoing charge to be stopped. That means using these functions also makes it very easy to put the charge point into a state that does not match up with what the CSMS is expecting, which can quickly lead to unexpected behavior.

If you only care about running the application you can find the latest release on the releases page we are currently building executables for Windows, Linux and MacOS.

We welcome contributions from everyone who is willing to improve this project. Whether you’re fixing bugs, adding new features, improving documentation, or suggesting new ideas, your help is greatly appreciated! Just make sure you follow these simple guidelines before opening up a PR:

• Follow the Code of Conduct: Always adhere to the Code of Conduct and be respectful of others in the community.
• Test Your Changes: Ensure your code is tested and as bug-free as possible.
• Update Documentation: If you’re adding new features or making changes that require it, update the documentation accordingly.

⚠️ Notice: This repository has been archived. For the latest examples utilizing label recognition features, please visit the Dynamsoft Capture Vision Samples repository. 🚀

This repository contains multiple samples that demonstrate how to use the Dynamsoft Label Recognizer .NET Edition.

• Windows:

  • Supported Versions: Windows 7 and higher, or Windows Server 2003 and higher
  • Architecture: x64 and x86
  • Development Environment: Visual Studio 2012 or higher.

• Linux:

  • Supported Distributions: Ubuntu 14.04.4+ LTS, Debian 8+, CentOS 6+
  • Architectures: x64
  • Minimum GLIBC Version: GLIBC_2.18 or higher

• Supported .NET versions

  • .NET Framework 3.5 and above
  • .NET 6, 7, 8

The library requires a license to work, you use the API LicenseManager.InitLicense to initialize license key and activate the SDK.

These samples use a free public trial license which require network connection to function. You can request a 30-day free trial license key from Customer Portal which works offline.

Contact Dynamsoft if you have any questions.

Rooster is a file filter for version control systems.

1. Clone the repo

git clone https://github.com/SheetJS/rooster.git rooster

2. Run go build

cd rooster
go build

In order to use rooster a config file must be provided:

Usage of ./rooster:
  -config string
        Rooster's config file (default ".rooster.yaml")

The layout of the .rooster.yaml is as follows:

- repo: https://github.com/foo/bar
  extensions:
    - docx
    - doc
    - xlsx
  out: foo_bar

- repo: https://github.com/baz/qux
  type: svn
  extensions:
    - .docx
    - .doc
    - xlsx
  out: baz_qux

- repo: https://github.com/quux/corge
  type: hg
  extensions:
    - md
    - "*.x*"

Each object must have the following keys:

• repo: The repository’s URL
• extension: An array of extensions to filter for

Note the following:

1. The leading . is optional, unless shell patterns are used (see below).
2. Standard shell patterns (as defined here) may be used.
   • If a shell pattern is used then the leading . becomes mandatory, and the extension must be enclosed in quotes.

The following keys are optional:

• type: The version control system to use (supported options: git,svn,hg) [default: git]
• out: The output directory to save the filtered files to (default: rooster_output_xxxx)

Once rooster is done each filtered repository will have a output directory similar to the one below:

rooster_output_xxx
├── doc
├── docx
└── txt

Where all docx files will be in the docx directory and all the doc files will be in the doc folder, etc, etc.

You’ll need to have your vcs provider installed on your system. An exception to this is git as rooster uses a go-based implementation of git.

The currently supported vcs’es are:

• Git
• Subversion
• Mercurial

Created at LogoMakr.com

For the awesome git library written in pure go.

For the awesome YAML parser.

All the resources used for the ‘PoeticScrapper’ Telegram bot. Please note that I used a laptop running Windows10 and I created, edited, and ran the subsequent codes via Atom (in which I installed additional packages on it).

The code(s) included in this repository:

a) telegramtestbed.py – this piece of code is mainly used to test the functionality of the bot (when it is newly created by BotFather), such as sending/receiving messages from specific users. This code need not be used anymore once the bot’s functionality is verified.

b) asynciobot.py – this piece of code is important to handle the user requests in terms of retrieving the required information from the website, i.e. establishing the asynchronous input/output characteristics of the bot, the type of replies to be sent to the user, and how long the bot will run for.

c) webscraper.py – this piece of code is the ‘heart of the telegram bot’ as it contains the main functions required for the web-scraping to be executed by the telegram bot.

d) poeticscrapperfinalcode.py – this piece of code is the final product that houses all the lines of code required to run the telegram bot locally. It possesses functions that are defined to (i) map keywords to specific actions and (ii) specify the elements on the webpage that will be scraped by the bot. All of these are enabled by the aforementioned bot1.py code (that has been inserted into this piece of code).

DISCLAIMER: The bot can be accessed by searching @PoeticScraper_bot on Telegram. However, do note that it can only run locally (on my laptop terminal) as of right now.

Note that scrapefm1.py (in ‘initial football manager idea’ folder) is the piece of code that I created for my initial project idea (SCRAPPED), and it does not have any bearing on the current Poetic Scraper bot. I inserted it into this repository as evidence to support my explantory piece.

Admin, AutoMod, Anime, Economy, Fun, Giveaway, Image, Invite, Information, Moderation, Music, Owner, Ticket, Utility and More…

Resource Links • Prerequisites • Getting Started • Features

• 🤖 Demo Bot: Invite Here
• 🤝 Support Server: Join Here

• Python 3.12.3 or higher
• Git

• Open the terminal and run the following commands

git clone https://github.com/Crypt06545/LORE
pip install -r requirements.txt
python main.py

• Wait for all the dependencies to be installed
• Rename .env.example to .env and fill the values

Before running the bot you will need to install all the requirements with this command:

python -m pip install -r requirements.txt

After that you can start it with

python main.py

If you need any additional help, make sure to read our guides here

• Moderation Commands.
  Commands: ban, unban, timeout, warn, …

• Anti system
  Commands: enable, anti spam, censor_enable,censor_words:add…
• Auto Delete system
  Commands: censor_links, autodelete invites, autodelete links, autodelete maxlines, …

• Let a bot be the server’s assistant!
  Commands: autorole, farewell, welcome, counters, flag translation, reaction roles, …
• Make custom settings for your own server.
  Commands: set_welcome_channel, enable_welcome, set_welcome_message, welcome_display…

• User Context Interactions
• Advanced Information Get deep information about a user, or Bot Developer

• LossLess Music! Enjoy high quality lossless music
• Multi-Platform Play music from YouTube, SoundCloud, Spotify, and more
• Filters Apply filters to your music and spice it up

• Easy to use Create giveaways with ease
• Role specific giveaways
• Customizable Customize the giveaway to your liking
• Limitless Create unlimited giveaways

• Make Supporting Members A Breeze With Tickets!
  Highly customizable ticket system with staff roles
• Multiple Categories
  Don’t Want The Tickets To Be Everywhere? Categorize them using select menus

• Levelling Track your server’s activity with a level system

• Need Some Help With Something? Use The Utility Commands To Find Out The Answer To It
  Commands: who, weather more …
• Need Help With Some More Stuff?
  Commands: help …

• Love Anime? Express You Love To Someone Using The React Commands
  Commands: anime, anime_picture, manga, …

• Want To Become Richest? Use The Economy Commands!
  Commands: bank, balance, beg, rob…
• Give People Money, Check Your Balance, Or Just Flex!
  Commands: bank balance, bank deposit, bank withdraw, bank transfer, …

• Have Some Fun In Your Server!
  Commands: meme, …
• Play Games And Enjoy Yourself
  Commands: tictactoe, rps, connect4…

• Generate Images Using Ai
  Commands: imagine
• Choose the Ai Model To generate
  Commands: models …

• Feel free to Fork this repository, create a feature branch and submit a pull request

Admin, AutoMod, Anime, Economy, Fun, Giveaway, Image, Invite, Information, Moderation, Music, Owner, Ticket, Utility and More…

Resource Links • Prerequisites • Getting Started • Features

• 🤖 Demo Bot: Invite Here
• 🤝 Support Server: Join Here

• Python 3.12.3 or higher
• Git

• Open the terminal and run the following commands

git clone https://github.com/Crypt06545/LORE
pip install -r requirements.txt
python main.py

• Wait for all the dependencies to be installed
• Rename .env.example to .env and fill the values

Before running the bot you will need to install all the requirements with this command:

python -m pip install -r requirements.txt

After that you can start it with

python main.py

If you need any additional help, make sure to read our guides here

• Moderation Commands.
  Commands: ban, unban, timeout, warn, …

• Anti system
  Commands: enable, anti spam, censor_enable,censor_words:add…
• Auto Delete system
  Commands: censor_links, autodelete invites, autodelete links, autodelete maxlines, …

• Let a bot be the server’s assistant!
  Commands: autorole, farewell, welcome, counters, flag translation, reaction roles, …
• Make custom settings for your own server.
  Commands: set_welcome_channel, enable_welcome, set_welcome_message, welcome_display…

• User Context Interactions
• Advanced Information Get deep information about a user, or Bot Developer

• LossLess Music! Enjoy high quality lossless music
• Multi-Platform Play music from YouTube, SoundCloud, Spotify, and more
• Filters Apply filters to your music and spice it up

• Easy to use Create giveaways with ease
• Role specific giveaways
• Customizable Customize the giveaway to your liking
• Limitless Create unlimited giveaways

• Make Supporting Members A Breeze With Tickets!
  Highly customizable ticket system with staff roles
• Multiple Categories
  Don’t Want The Tickets To Be Everywhere? Categorize them using select menus

• Levelling Track your server’s activity with a level system

• Need Some Help With Something? Use The Utility Commands To Find Out The Answer To It
  Commands: who, weather more …
• Need Help With Some More Stuff?
  Commands: help …

• Love Anime? Express You Love To Someone Using The React Commands
  Commands: anime, anime_picture, manga, …

• Want To Become Richest? Use The Economy Commands!
  Commands: bank, balance, beg, rob…
• Give People Money, Check Your Balance, Or Just Flex!
  Commands: bank balance, bank deposit, bank withdraw, bank transfer, …

• Have Some Fun In Your Server!
  Commands: meme, …
• Play Games And Enjoy Yourself
  Commands: tictactoe, rps, connect4…

• Generate Images Using Ai
  Commands: imagine
• Choose the Ai Model To generate
  Commands: models …

• Feel free to Fork this repository, create a feature branch and submit a pull request

The CPSwarm Communication Library provides a unified interface that tools and swarm members can use to interact with each other.

For more information, see the WIKI, the swarmio API documentation, or the swarmros message definitions.

Packages are built continuously with Bamboo.

Build should work on any Linux distribution, but packaging and architecture detection will only work on Debian and Ubuntu. By default, everything is compiled for the host architecture, but cross-compilation is available. Currently armhf and arm64 are supported if the required tools are available. The default compiler is clang, but GCC can also be used. Builds were tested with Ubuntu 16.04 and 18.04, with all the latest updates installed.

There are three build modes you can choose from:

 - DEVELOPMENT (default)

Development mode will build and install all components into one subdirectory under the build directory. Useful when an IDE needs a full include path and for debugging. By default, products are installed into the “devtree-” subdirectory.

 - PACKAGE

Package mode will build .deb packages for each target – and set /opt/swarmio as the install prefix. Find the packages under the “packages” subdirectory.

 - INSTALL

Install will install all outputs onto the local machine, by default under /opt/swarmio.

To build, create a new directory outside the source tree, and issue the following commands inside it:

 cmake <PATH TO SOURCE> [optional parameters]
 cmake --build .

Optional parameters:

 -DSWARMIO_BUILD_MODE=<MODE> (DEVELOPMENT, PACKAGE or INSTALL)

Specifies build mode (see above). DEVELOPMENT build will generate debug executables, while PACKAGE and INSTALL builds will compile with release flags (and debug symbols).

 -DCMAKE_BUILD_TYPE=<TYPE> (Debug, Release, RelWithDebInfo)

Override build type derrived from build mode. See CMake docs for more info.

 -DCMAKE_INSTALL_PREFIX=<PATH>

Overrides the installation directory. For DEVELOPMENT and INSTALL build, this will override the output directory. For PACKAGE builds, it will override the installation prefix of the generated packages.

 -DSWARMIO_TARGET_ARCHITECTURE=<ARCH> (armhf or arm64)

Enables cross-compilation – required tools must already be installed. On Ubuntu systems, crossbuild-essential- packages should do the trick.

 -DSWARMIO_BUILD_ROS_NODE=ON

If turned on, swarmros will be built.

 -DSWARMIO_MULTISTRAP_CONFIGURATION=<CONFIG>

If configured, a full multistrap sysroot will be initialized before cross-compilation. Requires multistrap and a bunch of other tools to be installed. Currently supported configurations:

• xenial (Ubuntu 16.04)
• xenial-ros (Ubuntu 16.04 with ROS Kinetic Kame)
• bionic (Ubuntu 18.04)
• bionic-ros (Ubuntu 18.04 with ROS Melodic Morenia)

-DSWARMIO_SYSROOT=<SYSROOT PATH>

If multistrap is not used, a sysroot needs to be manually set for cross-compilation to work. Ensure that the system image contains no absolute symbolic links before using it.

 -DSWARMIO_GCC_VERSION=<GCC VERSION>

If multistrap is not used, this should be set to indicate the GCC version present in the manually specified sysroot in order to help compilers find the correct libraries to link against.

 -DSWARMIO_ROS_PREFIX=<PATH>

Specifies the location of the ROS installation to use when building the ROS node. If not specified, the script will try to automatically detect it – by looking for the default installation directory of Kinetic Kame and Melodic Morenia.

 -DSWARMIO_PREFER_GCC=ON

If specified, GCC will be used instead of clang. Please note that cross-compilation will most likely only work if the same operating system (with a different architecture) is used on the host machine. Requires GCC 6 or later.

On Windows, only DEVELOPMENT mode is supported. Building the ROS node and multistrap environments are not supported. Basic build command is the same as on Linux:

 cmake <PATH TO SOURCE> [optional parameters]
 cmake --build .

Optional parameters:

 -DCMAKE_BUILD_TYPE=<TYPE> (Debug, Release, RelWithDebInfo)

Overrides the default build mode (Debug).

 -DCMAKE_INSTALL_PREFIX=<PATH>

Overrides the output directory.

 -DSWARMIO_TARGET_ARCHITECTURE=<ARCH> (x86 or x64)

Specifies whether to generate 32 or 64 bit builds.

If you want to generate packages for an armhf target, with ROS support turned on, targeting Ubuntu Xenial:

cmake <SOURCE_DIR> -DSWARMIO_BUILD_MODE=PACKAGE
                   -DSWARMIO_TARGET_ARCHITECTURE=armhf
                   -DSWARMIO_MULTISTRAP_CONFIGURATION=xenial-ros
                   -DSWARMIO_BUILD_ROS_NODE=ON
cmake --build .

All output packages will be placed into the packages subdirectory.

Contributions are welcome.

Please fork, make your changes, and submit a pull request. For major changes, please open an issue first and discuss it with the other authors.

This work is supported by the European Commission through the CPSwarm H2020 project under grant no. 731946.

Marvin is a shell script to set up an Mac OS laptop for development.

It can be run multiple times on the same machine safely. It installs, upgrades, or skips packages based on what is already installed on the machine.

We support:

• macOS Mavericks (10.9)
• macOS Yosemite (10.10)
• macOS El Capitan (10.11)
• macOS Sierra (10.12)

Older versions may work but aren’t regularly tested. Bug reports for older versions are welcome.

In your Terminal window, copy and paste the command below, then press return.

curl --silent https://raw.githubusercontent.com/ravisuhag/marvin/master/mac | sh 2>&1 | tee ~/marvin.log

The script itself is available in this repo for you to review if you want to see what it does and how it works.

Once the script is done, quit and relaunch Terminal.

It is highly recommended to run the script regularly to keep your computer up to date. Once the script has been installed, you’ll be able to run it at your convenience by typing laptop and pressing return in your Terminal.

Your last marvin run will be saved to ~/marvin.log. Read through it to see if you can debug the issue yourself. If not, copy the lines where the script failed into a new GitHub Issue for us. Or, attach the whole log file as an attachment.

• Homebrew for managing operating system libraries.

• Git for version control
• OpenSSL for Transport Layer Security (TLS)
• The Silver Searcher for finding things in files
• Zsh as your shell

• Node.js for running apps and installing JavaScript packages
• Go programming language by google
• Ruby a dynamic programming language with a focus on simplicity and productivity
• Clojure a dynamic, general-purpose programming language
• Java java Runtime Environment

• Yarn for managing JavaScript packages
• NPM node package manager
• Rbenv for managing versions of Ruby
• Ruby Build for installing Rubies
• Bundler for managing Ruby libraries
• Leiningen for automating Clojure projects
• Glide package Management for Go

• Consul service Discovery and Configuration Made Easy
• Zookeeper develop and maintain an open-source servers
• Kafka a distributed streaming platform
• GRPC a high performance, open-source universal RPC framework
• Image Magick to create, edit, compose, or convert bitmap images
• Heroku Toolbelt for interacting with the Heroku API
• Vagrant for development environments
• Chef for automating your infrastructure

• Postgres for storing relational data
• Redis for storing key-value data
• My Sql for storing relational data
• Mongo DB for storing non relational data

• youtube-dl download videos from YouTube
• htop interactive system-monitor
• tig text-mode interface for git
• logstalgia Website Access Log Visualization
• git-extras repo summary, repl, changelog population, author commit percentages
• fasd command-line productivity booster

• VLC media player
• Transmission bit torrent client
• Atom a hackable text editor
• Sublime Text sophisticated text editor for code
• Android Studio official IDE for Android
• Iterm mac terminal replacement
• Chrome fast, free web browser
• Blisk a browser for web developers
• Firefox a web browser by mozilla
• Sip collect, organize & share your colors
• Resolutionator embiggen your display
• Flux software to make your life better
• 1Password password manager
• Dropbox cloud file storage
• Google Drive safe place for your files
• Github Desktop collaboration from your desktop
• Virtual Box powerful virtualization tool
• Slack where work happens
• Rescuetime track app usages
• Tunnelblick free software for OpenVPN
• Spotify listen to your fav music
• Skype free calls to friends and family
• Postico a modern postgres client
• Mysql Workbench mysql client
• Dash offline access to API documentation sets.
• Tunnelbear Secure VPN service

It should take less than 20 minutes to install (depends on your machine).

Edit the mac file. Document in the README.md file. Follow shell style guidelines by using ShellCheck and Syntastic.

brew install shellcheck

Thank you, contributors!

marvin is inspired by laptop script, customized for my own needs. It is free software, and may be redistributed under the terms specified in the LICENSE file.