Alternatives to EventBus logo

Alternatives to EventBus

RxJava, Otto, RxJS, vuex, and Gradle are the most popular alternatives and competitors to EventBus.
49
33
+ 1
0

What is EventBus and what are its top alternatives?

It enables central communication to decoupled classes with just a few lines of code – simplifying the code, removing dependencies, and speeding up app development.
EventBus is a tool in the Java Build Tools category of a tech stack.
EventBus is an open source tool with 24.2K GitHub stars and 4.7K GitHub forks. Here’s a link to EventBus's open source repository on GitHub

Top Alternatives to EventBus

  • RxJava
    RxJava

    A library for composing asynchronous and event-based programs by using observable sequences for the Java VM. ...

  • Otto
    Otto

    Otto automatically builds development environments without any configuration; it can detect your project type and has built-in knowledge of industry-standard tools to setup a development environment that is ready to go. When you're ready to deploy, otto builds and manages an infrastructure, sets up servers, builds, and deploys the application. ...

  • RxJS
    RxJS

    RxJS is a library for reactive programming using Observables, to make it easier to compose asynchronous or callback-based code. This project is a rewrite of Reactive-Extensions/RxJS with better performance, better modularity, better debuggable call stacks, while staying mostly backwards compatible, with some breaking changes that reduce the API surface. ...

  • vuex
    vuex

    Vuex is a state management pattern + library for Vue.js applications. It serves as a centralized store for all the components in an application, with rules ensuring that the state can only be mutated in a predictable fashion. It also integrates with Vue's official devtools extension to provide advanced features such as zero-config time-travel debugging and state snapshot export / import. ...

  • Gradle
    Gradle

    Gradle is a build tool with a focus on build automation and support for multi-language development. If you are building, testing, publishing, and deploying software on any platform, Gradle offers a flexible model that can support the entire development lifecycle from compiling and packaging code to publishing web sites. ...

  • Apache Maven
    Apache Maven

    Maven allows a project to build using its project object model (POM) and a set of plugins that are shared by all projects using Maven, providing a uniform build system. Once you familiarize yourself with how one Maven project builds you automatically know how all Maven projects build saving you immense amounts of time when trying to navigate many projects. ...

  • guava
    guava

    The Guava project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, and so forth. ...

  • CMake
    CMake

    It is used to control the software compilation process using simple platform and compiler independent configuration files, and generate native makefiles and workspaces that can be used in the compiler environment of the user's choice. ...

EventBus alternatives & related posts

RxJava logo

RxJava

323
166
1
Reactive Extensions for the JVM
323
166
+ 1
1
PROS OF RXJAVA
  • 1
    Reactive Libraries as per Reactive Manifesto
CONS OF RXJAVA
    Be the first to leave a con

    related RxJava posts

    Luis Pena
    Cloud Solution Architect at AWS · | 2 upvotes · 30.2K views
    Shared insights
    on
    QuarkusQuarkusRxJavaRxJava

    Can I mix RxJava with Quarkus?

    See more
    Otto logo

    Otto

    25
    86
    18
    Development and Deployment Made Easy. The successor to Vagrant
    25
    86
    + 1
    18
    PROS OF OTTO
    • 11
      Vagrant-like
    • 4
      Written in golang
    • 3
      Hashicorp built
    CONS OF OTTO
      Be the first to leave a con

      related Otto posts

      RxJS logo

      RxJS

      2.9K
      597
      19
      The Reactive Extensions for JavaScript
      2.9K
      597
      + 1
      19
      PROS OF RXJS
      • 5
        Easier async data chaining and combining
      • 3
        Steep learning curve, but offers predictable operations
      • 2
        Easier testing
      • 2
        Ability to build your own stream
      • 2
        Works great with any state management implementation
      • 1
        Lot of build-in operators
      • 1
        Simplifies state management
      • 1
        Observable subjects
      • 1
        Great for push based architecture
      • 1
        Documentation
      CONS OF RXJS
      • 3
        Steep learning curve

      related RxJS posts

      vuex logo

      vuex

      1.3K
      896
      7
      Centralized State Management for Vue.js.
      1.3K
      896
      + 1
      7
      PROS OF VUEX
      • 2
        Debugging
      • 2
        Zero-config time-travel
      • 2
        Centralized State Management
      • 1
        Easy to setup
      CONS OF VUEX
        Be the first to leave a con

        related vuex posts

        Simon Reymann
        Senior Fullstack Developer at QUANTUSflow Software GmbH · | 23 upvotes · 1.8M views

        Our whole Vue.js frontend stack (incl. SSR) consists of the following tools:

        • Nuxt.js consisting of Vue CLI, Vue Router, vuex, Webpack and Sass (Bundler for HTML5, CSS 3), Babel (Transpiler for JavaScript),
        • Vue Styleguidist as our style guide and pool of developed Vue.js components
        • Vuetify as Material Component Framework (for fast app development)
        • TypeScript as programming language
        • Apollo / GraphQL (incl. GraphiQL) for data access layer (https://apollo.vuejs.org/)
        • ESLint, TSLint and Prettier for coding style and code analyzes
        • Jest as testing framework
        • Google Fonts and Font Awesome for typography and icon toolkit
        • NativeScript-Vue for mobile development

        The main reason we have chosen Vue.js over React and AngularJS is related to the following artifacts:

        • Empowered HTML. Vue.js has many similar approaches with Angular. This helps to optimize HTML blocks handling with the use of different components.
        • Detailed documentation. Vue.js has very good documentation which can fasten learning curve for developers.
        • Adaptability. It provides a rapid switching period from other frameworks. It has similarities with Angular and React in terms of design and architecture.
        • Awesome integration. Vue.js can be used for both building single-page applications and more difficult web interfaces of apps. Smaller interactive parts can be easily integrated into the existing infrastructure with no negative effect on the entire system.
        • Large scaling. Vue.js can help to develop pretty large reusable templates.
        • Tiny size. Vue.js weights around 20KB keeping its speed and flexibility. It allows reaching much better performance in comparison to other frameworks.
        See more

        Vue.js vuex Vue Router Quasar Framework Electron Node.js npm Yarn Git GitHub Netlify My tech stack that helps me develop quickly and efficiently. Wouldn't want it any other way.

        See more
        Gradle logo

        Gradle

        15.9K
        8.4K
        254
        A powerful build system for the JVM
        15.9K
        8.4K
        + 1
        254
        PROS OF GRADLE
        • 110
          Flexibility
        • 51
          Easy to use
        • 47
          Groovy dsl
        • 22
          Slow build time
        • 10
          Crazy memory leaks
        • 8
          Fast incremental builds
        • 5
          Kotlin DSL
        • 1
          Windows Support
        CONS OF GRADLE
        • 7
          Inactionnable documentation
        • 6
          It is just the mess of Ant++
        • 4
          Hard to decide: ten or more ways to achieve one goal
        • 2
          Bad Eclipse tooling
        • 2
          Dependency on groovy

        related Gradle posts

        Shared insights
        on
        Apache MavenApache MavenGradleGradle
        at

        We use Apache Maven because it is a standard. Gradle is very good alternative, but Gradle doesn't provide any advantage for our project. Gradle is slower (without running daemon), need more resources and a learning curve is quite big. Our project can not use a great flexibility of Gradle. On the other hand, Maven is well-know tool integrated in many IDEs, Dockers and so on.

        See more
        Application & Data

        Java JavaScript Node.js nginx Ubuntu MongoDB Amazon EC2 Redis Amazon S3 AWS Lambda RabbitMQ Kafka MySQL Spring Boot Dropwizard Vue.js Flutter

        Utilities

        Google Analytics Elasticsearch Amazon Route 53

        DevOps

        GitHub Docker Webpack CircleCI Jenkins Travis CI Gradle Apache Maven

        Cooperation Tools

        Jira notion.so Trello

        See more
        Apache Maven logo

        Apache Maven

        2.7K
        1.6K
        414
        Apache build manager for Java projects.
        2.7K
        1.6K
        + 1
        414
        PROS OF APACHE MAVEN
        • 137
          Dependency management
        • 71
          Necessary evil
        • 60
          I’d rather code my app, not my build
        • 48
          Publishing packaged artifacts
        • 43
          Convention over configuration
        • 18
          Modularisation
        • 11
          Consistency across builds
        • 6
          Prevents overengineering using scripting
        • 4
          Runs Tests
        • 4
          Lot of cool plugins
        • 3
          Extensible
        • 2
          Hard to customize
        • 2
          Runs on Linux
        • 1
          Runs on OS X
        • 1
          Slow incremental build
        • 1
          Inconsistent buillds
        • 1
          Undeterminisc
        • 1
          Good IDE tooling
        CONS OF APACHE MAVEN
        • 6
          Complex
        • 1
          Inconsistent buillds
        • 0
          Not many plugin-alternatives

        related Apache Maven posts

        Tymoteusz Paul
        Devops guy at X20X Development LTD · | 23 upvotes · 5.6M views

        Often enough I have to explain my way of going about setting up a CI/CD pipeline with multiple deployment platforms. Since I am a bit tired of yapping the same every single time, I've decided to write it up and share with the world this way, and send people to read it instead ;). I will explain it on "live-example" of how the Rome got built, basing that current methodology exists only of readme.md and wishes of good luck (as it usually is ;)).

        It always starts with an app, whatever it may be and reading the readmes available while Vagrant and VirtualBox is installing and updating. Following that is the first hurdle to go over - convert all the instruction/scripts into Ansible playbook(s), and only stopping when doing a clear vagrant up or vagrant reload we will have a fully working environment. As our Vagrant environment is now functional, it's time to break it! This is the moment to look for how things can be done better (too rigid/too lose versioning? Sloppy environment setup?) and replace them with the right way to do stuff, one that won't bite us in the backside. This is the point, and the best opportunity, to upcycle the existing way of doing dev environment to produce a proper, production-grade product.

        I should probably digress here for a moment and explain why. I firmly believe that the way you deploy production is the same way you should deploy develop, shy of few debugging-friendly setting. This way you avoid the discrepancy between how production work vs how development works, which almost always causes major pains in the back of the neck, and with use of proper tools should mean no more work for the developers. That's why we start with Vagrant as developer boxes should be as easy as vagrant up, but the meat of our product lies in Ansible which will do meat of the work and can be applied to almost anything: AWS, bare metal, docker, LXC, in open net, behind vpn - you name it.

        We must also give proper consideration to monitoring and logging hoovering at this point. My generic answer here is to grab Elasticsearch, Kibana, and Logstash. While for different use cases there may be better solutions, this one is well battle-tested, performs reasonably and is very easy to scale both vertically (within some limits) and horizontally. Logstash rules are easy to write and are well supported in maintenance through Ansible, which as I've mentioned earlier, are at the very core of things, and creating triggers/reports and alerts based on Elastic and Kibana is generally a breeze, including some quite complex aggregations.

        If we are happy with the state of the Ansible it's time to move on and put all those roles and playbooks to work. Namely, we need something to manage our CI/CD pipelines. For me, the choice is obvious: TeamCity. It's modern, robust and unlike most of the light-weight alternatives, it's transparent. What I mean by that is that it doesn't tell you how to do things, doesn't limit your ways to deploy, or test, or package for that matter. Instead, it provides a developer-friendly and rich playground for your pipelines. You can do most the same with Jenkins, but it has a quite dated look and feel to it, while also missing some key functionality that must be brought in via plugins (like quality REST API which comes built-in with TeamCity). It also comes with all the common-handy plugins like Slack or Apache Maven integration.

        The exact flow between CI and CD varies too greatly from one application to another to describe, so I will outline a few rules that guide me in it: 1. Make build steps as small as possible. This way when something breaks, we know exactly where, without needing to dig and root around. 2. All security credentials besides development environment must be sources from individual Vault instances. Keys to those containers should exist only on the CI/CD box and accessible by a few people (the less the better). This is pretty self-explanatory, as anything besides dev may contain sensitive data and, at times, be public-facing. Because of that appropriate security must be present. TeamCity shines in this department with excellent secrets-management. 3. Every part of the build chain shall consume and produce artifacts. If it creates nothing, it likely shouldn't be its own build. This way if any issue shows up with any environment or version, all developer has to do it is grab appropriate artifacts to reproduce the issue locally. 4. Deployment builds should be directly tied to specific Git branches/tags. This enables much easier tracking of what caused an issue, including automated identifying and tagging the author (nothing like automated regression testing!).

        Speaking of deployments, I generally try to keep it simple but also with a close eye on the wallet. Because of that, I am more than happy with AWS or another cloud provider, but also constantly peeking at the loads and do we get the value of what we are paying for. Often enough the pattern of use is not constantly erratic, but rather has a firm baseline which could be migrated away from the cloud and into bare metal boxes. That is another part where this approach strongly triumphs over the common Docker and CircleCI setup, where you are very much tied in to use cloud providers and getting out is expensive. Here to embrace bare-metal hosting all you need is a help of some container-based self-hosting software, my personal preference is with Proxmox and LXC. Following that all you must write are ansible scripts to manage hardware of Proxmox, similar way as you do for Amazon EC2 (ansible supports both greatly) and you are good to go. One does not exclude another, quite the opposite, as they can live in great synergy and cut your costs dramatically (the heavier your base load, the bigger the savings) while providing production-grade resiliency.

        See more
        Shared insights
        on
        Apache MavenApache MavenGradleGradle
        at

        We use Apache Maven because it is a standard. Gradle is very good alternative, but Gradle doesn't provide any advantage for our project. Gradle is slower (without running daemon), need more resources and a learning curve is quite big. Our project can not use a great flexibility of Gradle. On the other hand, Maven is well-know tool integrated in many IDEs, Dockers and so on.

        See more
        guava logo

        guava

        1.2K
        178
        6
        Google Core Libraries for Java 6+
        1.2K
        178
        + 1
        6
        PROS OF GUAVA
        • 5
          Interface Driven API
        • 1
          Easy to setup
        CONS OF GUAVA
          Be the first to leave a con

          related guava posts

          CMake logo

          CMake

          927
          265
          1
          An open-source system that manages the build process
          927
          265
          + 1
          1
          PROS OF CMAKE
          • 1
            Has package registry
          CONS OF CMAKE
            Be the first to leave a con

            related CMake posts