Alternatives to Babel logo

Alternatives to Babel

Webpack, TypeScript, CoffeeScript, ESLint, and rollup are the most popular alternatives and competitors to Babel.
21.9K
10.8K
+ 1
391

What is Babel and what are its top alternatives?

Babel is a widely-used JavaScript compiler that allows developers to write code using the latest ECMAScript standards and then converts it into backwards-compatible versions for different environments. It enables developers to use modern JavaScript features like arrow functions, async/await, and classes, even if the target environment does not support these features. However, Babel can sometimes be slow in compilation and may have issues with complex configurations.

  1. TypeScript: TypeScript is a superset of JavaScript that adds static typing to the language, offering improved maintainability and scalability. Key features include type checking, interfaces, and compilation to JavaScript. Pros: Enhanced code readability and type safety. Cons: Learning curve for developers accustomed to dynamically-typed languages.
  2. Webpack: Webpack is a module bundler that can also handle transformations through loaders, making it an alternative to Babel for JavaScript transpilation. Key features include code splitting, hot module replacement, and tree shaking. Pros: Simplifies dependency management. Cons: Configuration can be complex.
  3. SWC: SWC is a super-fast JavaScript/TypeScript compiler that aims to be a drop-in replacement for Babel. Key features include speed and compatibility with Babel plugins. Pros: High performance and extensive compatibility. Cons: Less community support compared to Babel.
  4. Rollup: Rollup is a JavaScript module bundler that emphasizes tree-shaking for better code optimization. Key features include ES module support and code-splitting. Pros: Efficient bundle sizes. Cons: Less flexibility compared to tools like Webpack.
  5. Esbuild: Esbuild is an extremely fast JavaScript bundler that focuses on speed and low overhead. Key features include ES module importing and tree-shaking. Pros: Lightning-fast compilation times. Cons: Limited plugin ecosystem compared to Babel.
  6. Traceur: Traceur is a JavaScript compiler that aims to support next-generation JavaScript features with a focus on ES6 compatibility. Key features include support for experimental features and a pluggable system. Pros: Early adoption of upcoming ECMAScript standards. Cons: Less active development compared to other tools.
  7. Closure Compiler: Closure Compiler is a tool from Google that performs JavaScript optimization, including minification and dead code elimination. Key features include advanced optimizations and type checking. Pros: Excellent for optimizing production code. Cons: Steeper learning curve compared to simpler tools.
  8. Dart: Dart is a programming language developed by Google that can transpile to JavaScript and offers comprehensive tooling for web development. Key features include a concise syntax, strong typing, and Flutter integration. Pros: Single language for frontend and backend development. Cons: Limited adoption compared to JavaScript alternatives.
  9. UglifyJS: UglifyJS is a JavaScript minifier that can also perform some code transformations, providing a lightweight alternative to Babel for simple projects. Key features include minification and dead code elimination. Pros: Fast processing speed. Cons: Limited in scope compared to full-fledged compilers.
  10. CoffeeScript: CoffeeScript is a little language that compiles into JavaScript, offering a more concise and readable syntax for web development. Key features include clean syntax and significant whitespace for improved readability. Pros: Reduced boilerplate code. Cons: Compatibility issues with modern JavaScript features.

Top Alternatives to Babel

  • Webpack
    Webpack

    A bundler for javascript and friends. Packs many modules into a few bundled assets. Code Splitting allows to load parts for the application on demand. Through "loaders" modules can be CommonJs, AMD, ES6 modules, CSS, Images, JSON, Coffeescript, LESS, ... and your custom stuff. ...

  • TypeScript
    TypeScript

    TypeScript is a language for application-scale JavaScript development. It's a typed superset of JavaScript that compiles to plain JavaScript. ...

  • CoffeeScript
    CoffeeScript

    It adds syntactic sugar inspired by Ruby, Python and Haskell in an effort to enhance JavaScript's brevity and readability. Specific additional features include list comprehension and de-structuring assignment. ...

  • ESLint
    ESLint

    A pluggable and configurable linter tool for identifying and reporting on patterns in JavaScript. Maintain your code quality with ease. ...

  • rollup
    rollup

    It is a module bundler for JavaScript which compiles small pieces of code into something larger and more complex, such as a library or application. It uses the new standardized format for code modules included in the ES6 revision of JavaScript, instead of previous idiosyncratic solutions such as CommonJS and AMD. ...

  • JavaScript
    JavaScript

    JavaScript is most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic,and supports object-oriented, imperative, and functional programming styles. ...

  • Git
    Git

    Git is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. ...

  • GitHub
    GitHub

    GitHub is the best place to share code with friends, co-workers, classmates, and complete strangers. Over three million people use GitHub to build amazing things together. ...

Babel alternatives & related posts

Webpack logo

Webpack

40.1K
27.1K
752
A bundler for javascript and friends
40.1K
27.1K
+ 1
752
PROS OF WEBPACK
  • 309
    Most powerful bundler
  • 182
    Built-in dev server with livereload
  • 142
    Can handle all types of assets
  • 87
    Easy configuration
  • 22
    Laravel-mix
  • 4
    Overengineered, Underdeveloped
  • 2
    Makes it easy to bundle static assets
  • 2
    Webpack-Encore
  • 1
    Redundant
  • 1
    Better support in Browser Dev-Tools
CONS OF WEBPACK
  • 15
    Hard to configure
  • 5
    No clear direction
  • 2
    Spaghetti-Code out of the box
  • 2
    SystemJS integration is quite lackluster
  • 2
    Loader architecture is quite a mess (unreliable/buggy)
  • 2
    Fire and Forget mentality of Core-Developers

related Webpack posts

Russel Werner
Lead Engineer at StackShare · | 32 upvotes · 2.2M views

StackShare Feed is built entirely with React, Glamorous, and Apollo. One of our objectives with the public launch of the Feed was to enable a Server-side rendered (SSR) experience for our organic search traffic. When you visit the StackShare Feed, and you aren't logged in, you are delivered the Trending feed experience. We use an in-house Node.js rendering microservice to generate this HTML. This microservice needs to run and serve requests independent of our Rails web app. Up until recently, we had a mono-repo with our Rails and React code living happily together and all served from the same web process. In order to deploy our SSR app into a Heroku environment, we needed to split out our front-end application into a separate repo in GitHub. The driving factor in this decision was mostly due to limitations imposed by Heroku specifically with how processes can't communicate with each other. A new SSR app was created in Heroku and linked directly to the frontend repo so it stays in-sync with changes.

Related to this, we need a way to "deploy" our frontend changes to various server environments without building & releasing the entire Ruby application. We built a hybrid Amazon S3 Amazon CloudFront solution to host our Webpack bundles. A new CircleCI script builds the bundles and uploads them to S3. The final step in our rollout is to update some keys in Redis so our Rails app knows which bundles to serve. The result of these efforts were significant. Our frontend team now moves independently of our backend team, our build & release process takes only a few minutes, we are now using an edge CDN to serve JS assets, and we have pre-rendered React pages!

#StackDecisionsLaunch #SSR #Microservices #FrontEndRepoSplit

See more
Jonathan Pugh
Software Engineer / Project Manager / Technical Architect · | 25 upvotes · 2.9M views

I needed to choose a full stack of tools for cross platform mobile application design & development. After much research and trying different tools, these are what I came up with that work for me today:

For the client coding I chose Framework7 because of its performance, easy learning curve, and very well designed, beautiful UI widgets. I think it's perfect for solo development or small teams. I didn't like React Native. It felt heavy to me and rigid. Framework7 allows the use of #CSS3, which I think is the best technology to come out of the #WWW movement. No other tech has been able to allow designers and developers to develop such flexible, high performance, customisable user interface elements that are highly responsive and hardware accelerated before. Now #CSS3 includes variables and flexboxes it is truly a powerful language and there is no longer a need for preprocessors such as #SCSS / #Sass / #less. React Native contains a very limited interpretation of #CSS3 which I found very frustrating after using #CSS3 for some years already and knowing its powerful features. The other very nice feature of Framework7 is that you can even build for the browser if you want your app to be available for desktop web browsers. The latest release also includes the ability to build for #Electron so you can have MacOS, Windows and Linux desktop apps. This is not possible with React Native yet.

Framework7 runs on top of Apache Cordova. Cordova and webviews have been slated as being slow in the past. Having a game developer background I found the tweeks to make it run as smooth as silk. One of those tweeks is to use WKWebView. Another important one was using srcset on images.

I use #Template7 for the for the templating system which is a no-nonsense mobile-centric #HandleBars style extensible templating system. It's easy to write custom helpers for, is fast and has a small footprint. I'm not forced into a new paradigm or learning some new syntax. It operates with standard JavaScript, HTML5 and CSS 3. It's written by the developer of Framework7 and so dovetails with it as expected.

I configured TypeScript to work with the latest version of Framework7. I consider TypeScript to be one of the best creations to come out of Microsoft in some time. They must have an amazing team working on it. It's very powerful and flexible. It helps you catch a lot of bugs and also provides code completion in supporting IDEs. So for my IDE I use Visual Studio Code which is a blazingly fast and silky smooth editor that integrates seamlessly with TypeScript for the ultimate type checking setup (both products are produced by Microsoft).

I use Webpack and Babel to compile the JavaScript. TypeScript can compile to JavaScript directly but Babel offers a few more options and polyfills so you can use the latest (and even prerelease) JavaScript features today and compile to be backwards compatible with virtually any browser. My favorite recent addition is "optional chaining" which greatly simplifies and increases readability of a number of sections of my code dealing with getting and setting data in nested objects.

I use some Ruby scripts to process images with ImageMagick and pngquant to optimise for size and even auto insert responsive image code into the HTML5. Ruby is the ultimate cross platform scripting language. Even as your scripts become large, Ruby allows you to refactor your code easily and make it Object Oriented if necessary. I find it the quickest and easiest way to maintain certain aspects of my build process.

For the user interface design and prototyping I use Figma. Figma has an almost identical user interface to #Sketch but has the added advantage of being cross platform (MacOS and Windows). Its real-time collaboration features are outstanding and I use them a often as I work mostly on remote projects. Clients can collaborate in real-time and see changes I make as I make them. The clickable prototyping features in Figma are also very well designed and mean I can send clickable prototypes to clients to try user interface updates as they are made and get immediate feedback. I'm currently also evaluating the latest version of #AdobeXD as an alternative to Figma as it has the very cool auto-animate feature. It doesn't have real-time collaboration yet, but I heard it is proposed for 2019.

For the UI icons I use Font Awesome Pro. They have the largest selection and best looking icons you can find on the internet with several variations in styles so you can find most of the icons you want for standard projects.

For the backend I was using the #GraphCool Framework. As I later found out, #GraphQL still has some way to go in order to provide the full power of a mature graph query language so later in my project I ripped out #GraphCool and replaced it with CouchDB and Pouchdb. Primarily so I could provide good offline app support. CouchDB with Pouchdb is very flexible and efficient combination and overcomes some of the restrictions I found in #GraphQL and hence #GraphCool also. The most impressive and important feature of CouchDB is its replication. You can configure it in various ways for backups, fault tolerance, caching or conditional merging of databases. CouchDB and Pouchdb even supports storing, retrieving and serving binary or image data or other mime types. This removes a level of complexity usually present in database implementations where binary or image data is usually referenced through an #HTML5 link. With CouchDB and Pouchdb apps can operate offline and sync later, very efficiently, when the network connection is good.

I use PhoneGap when testing the app. It auto-reloads your app when its code is changed and you can also install it on Android phones to preview your app instantly. iOS is a bit more tricky cause of Apple's policies so it's not available on the App Store, but you can build it and install it yourself to your device.

So that's my latest mobile stack. What tools do you use? Have you tried these ones?

See more
TypeScript logo

TypeScript

91.6K
70.7K
502
A superset of JavaScript that compiles to clean JavaScript output
91.6K
70.7K
+ 1
502
PROS OF TYPESCRIPT
  • 174
    More intuitive and type safe javascript
  • 106
    Type safe
  • 80
    JavaScript superset
  • 48
    The best AltJS ever
  • 27
    Best AltJS for BackEnd
  • 15
    Powerful type system, including generics & JS features
  • 11
    Compile time errors
  • 11
    Nice and seamless hybrid of static and dynamic typing
  • 10
    Aligned with ES development for compatibility
  • 7
    Angular
  • 7
    Structural, rather than nominal, subtyping
  • 5
    Starts and ends with JavaScript
  • 1
    Garbage collection
CONS OF TYPESCRIPT
  • 5
    Code may look heavy and confusing
  • 4
    Hype

related TypeScript posts

Yshay Yaacobi

Our first experience with .NET core was when we developed our OSS feature management platform - Tweek (https://github.com/soluto/tweek). We wanted to create a solution that is able to run anywhere (super important for OSS), has excellent performance characteristics and can fit in a multi-container architecture. We decided to implement our rule engine processor in F# , our main service was implemented in C# and other components were built using JavaScript / TypeScript and Go.

Visual Studio Code worked really well for us as well, it worked well with all our polyglot services and the .Net core integration had great cross-platform developer experience (to be fair, F# was a bit trickier) - actually, each of our team members used a different OS (Ubuntu, macos, windows). Our production deployment ran for a time on Docker Swarm until we've decided to adopt Kubernetes with almost seamless migration process.

After our positive experience of running .Net core workloads in containers and developing Tweek's .Net services on non-windows machines, C# had gained back some of its popularity (originally lost to Node.js), and other teams have been using it for developing microservices, k8s sidecars (like https://github.com/Soluto/airbag), cli tools, serverless functions and other projects...

See more
Adebayo Akinlaja
Engineering Manager at Andela · | 30 upvotes · 3.3M views

I picked up an idea to develop and it was no brainer I had to go with React for the frontend. I was faced with challenges when it came to what component framework to use. I had worked extensively with Material-UI but I needed something different that would offer me wider range of well customized components (I became pretty slow at styling). I brought in Evergreen after several sampling and reads online but again, after several prototype development against Evergreen—since I was using TypeScript and I had to import custom Type, it felt exhaustive. After I validated Evergreen with the designs of the idea I was developing, I also noticed I might have to do a lot of styling. I later stumbled on Material Kit, the one specifically made for React . It was promising with beautifully crafted components, most of which fits into the designs pages I had on ground.

A major problem of Material Kit for me is it isn't written in TypeScript and there isn't any plans to support its TypeScript version. I rolled up my sleeve and started converting their components to TypeScript and if you'll ask me, I am still on it.

In summary, I used the Create React App with TypeScript support and I am spending some time converting Material Kit to TypeScript before I start developing against it. All of these components are going to be hosted on Bit.

If you feel I am crazy or I have gotten something wrong, I'll be willing to listen to your opinion. Also, if you want to have a share of whatever TypeScript version of Material Kit I end up coming up with, let me know.

See more
CoffeeScript logo

CoffeeScript

3.3K
1.2K
1K
A little language that compiles into JavaScript
3.3K
1.2K
+ 1
1K
PROS OF COFFEESCRIPT
  • 199
    Easy to read
  • 179
    Faster to write
  • 126
    Syntactic sugar
  • 104
    Readable
  • 104
    Elegant
  • 73
    Pretty
  • 53
    Javascript the good parts
  • 48
    Open source
  • 44
    Classes
  • 35
    "it's just javascript"
  • 16
    Compact code
  • 15
    Easy
  • 13
    Simple
  • 13
    Not Javascript
  • 2
    Does the same with less code
  • 1
    I'm jobs I'm software engineer
CONS OF COFFEESCRIPT
  • 3
    No ES6
  • 1
    Corner cases in syntax
  • 1
    Parentheses required in 0-ary function calls
  • 1
    Unclear what will be grouped to {…}

related CoffeeScript posts

Jake Stein

Stitch’s frontend is used to configure data sources and destinations and monitor the status of each. Although we have been using AngularJS since its early days, we recently introduced React components into our front end, which many of our developers find easier to work with. We started using CoffeeScript when it was one of the few options for a more expressive alternative to vanilla JavaScript, but today we opt to instead write new code in ES6, which we feel is a more mature alternative.

See more
Eli Hooten

We chose TypeScript at Codecov when undergoing a recent rewrite of a legacy front end. Our previous front end was a mishmash of vanilla JavaScript and CoffeeScript , and was expanded upon haphazardly as the need arose. Without a unifying set of paradigms and patterns, the CoffeeScript and JavaScript setup was proving hard to maintain and expand upon by an engineering team. During a move to Vue.js , we decided to also make the move to TypeScript. Integrating TypeScript and Vue.js is fairly well understood at this point, so the setup wasn't all that difficult, and we felt that the benefits of incorporating TypeScript would outweigh the required time to set it up and get our engineering team up to speed.

Choosing to add TypeScript has given us one more layer to rely on to help enforce code quality, good standards, and best practices within our engineering organization. One of the biggest benefits for us as an engineering team has been how well our IDEs and editors (e.g., Visual Studio Code ) integrate with and understand TypeScript . This allows developers to catch many more errors at development time instead of relying on run time. The end result is safer (from a type perspective) code and a more efficient coding experience that helps to catch and remove errors with less developer effort.

See more
ESLint logo

ESLint

29.2K
13.4K
28
The fully pluggable JavaScript code quality tool
29.2K
13.4K
+ 1
28
PROS OF ESLINT
  • 8
    Consistent javascript - opinions don't matter anymore
  • 6
    Free
  • 6
    IDE Integration
  • 4
    Customizable
  • 2
    Focuses code review on quality not style
  • 2
    Broad ecosystem of support & users
CONS OF ESLINT
    Be the first to leave a con

    related ESLint posts

    Simon Reymann
    Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 9.3M views

    Our whole DevOps stack consists of the following tools:

    • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
    • Respectively Git as revision control system
    • SourceTree as Git GUI
    • Visual Studio Code as IDE
    • CircleCI for continuous integration (automatize development process)
    • Prettier / TSLint / ESLint as code linter
    • SonarQube as quality gate
    • Docker as container management (incl. Docker Compose for multi-container application management)
    • VirtualBox for operating system simulation tests
    • Kubernetes as cluster management for docker containers
    • Heroku for deploying in test environments
    • nginx as web server (preferably used as facade server in production environment)
    • SSLMate (using OpenSSL) for certificate management
    • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
    • PostgreSQL as preferred database system
    • Redis as preferred in-memory database/store (great for caching)

    The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

    • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
    • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
    • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
    • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
    • Scalability: All-in-one framework for distributed systems.
    • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
    See more
    Simon Reymann
    Senior Fullstack Developer at QUANTUSflow Software GmbH · | 23 upvotes · 4.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
    rollup logo

    rollup

    1.7K
    163
    17
    The next-generation JavaScript module bundler
    1.7K
    163
    + 1
    17
    PROS OF ROLLUP
    • 4
      Makes it easy to publish packages
    • 3
      Easier configuration
    • 2
      Better tree shaking
    • 2
      Provides smaller bundle size
    • 1
      Integrates seamlessly with SystemJS
    • 1
      Produces very clean code
    • 1
      Very reliable
    • 1
      Very robust Plugin-API (years old Plugins still work)
    • 1
      Very flexible
    • 1
      Was built with ESM-Modules in mind
    CONS OF ROLLUP
    • 1
      No clear path for static assets
    • 1
      No Loader like Webpack (need to use sjs or ESM imports)
    • 1
      Almost everything needs to be a Plugin
    • 1
      Manual Chunking is a bit buggy

    related rollup posts

    JavaScript logo

    JavaScript

    351.4K
    267.6K
    8.1K
    Lightweight, interpreted, object-oriented language with first-class functions
    351.4K
    267.6K
    + 1
    8.1K
    PROS OF JAVASCRIPT
    • 1.7K
      Can be used on frontend/backend
    • 1.5K
      It's everywhere
    • 1.2K
      Lots of great frameworks
    • 897
      Fast
    • 745
      Light weight
    • 425
      Flexible
    • 392
      You can't get a device today that doesn't run js
    • 286
      Non-blocking i/o
    • 237
      Ubiquitousness
    • 191
      Expressive
    • 55
      Extended functionality to web pages
    • 49
      Relatively easy language
    • 46
      Executed on the client side
    • 30
      Relatively fast to the end user
    • 25
      Pure Javascript
    • 21
      Functional programming
    • 15
      Async
    • 13
      Full-stack
    • 12
      Setup is easy
    • 12
      Future Language of The Web
    • 12
      Its everywhere
    • 11
      Because I love functions
    • 11
      JavaScript is the New PHP
    • 10
      Like it or not, JS is part of the web standard
    • 9
      Expansive community
    • 9
      Everyone use it
    • 9
      Can be used in backend, frontend and DB
    • 9
      Easy
    • 8
      Most Popular Language in the World
    • 8
      Powerful
    • 8
      Can be used both as frontend and backend as well
    • 8
      For the good parts
    • 8
      No need to use PHP
    • 8
      Easy to hire developers
    • 7
      Agile, packages simple to use
    • 7
      Love-hate relationship
    • 7
      Photoshop has 3 JS runtimes built in
    • 7
      Evolution of C
    • 7
      It's fun
    • 7
      Hard not to use
    • 7
      Versitile
    • 7
      Its fun and fast
    • 7
      Nice
    • 7
      Popularized Class-Less Architecture & Lambdas
    • 7
      Supports lambdas and closures
    • 6
      It let's me use Babel & Typescript
    • 6
      Can be used on frontend/backend/Mobile/create PRO Ui
    • 6
      1.6K Can be used on frontend/backend
    • 6
      Client side JS uses the visitors CPU to save Server Res
    • 6
      Easy to make something
    • 5
      Clojurescript
    • 5
      Promise relationship
    • 5
      Stockholm Syndrome
    • 5
      Function expressions are useful for callbacks
    • 5
      Scope manipulation
    • 5
      Everywhere
    • 5
      Client processing
    • 5
      What to add
    • 4
      Because it is so simple and lightweight
    • 4
      Only Programming language on browser
    • 1
      Test
    • 1
      Hard to learn
    • 1
      Test2
    • 1
      Not the best
    • 1
      Easy to understand
    • 1
      Subskill #4
    • 1
      Easy to learn
    • 0
      Hard 彤
    CONS OF JAVASCRIPT
    • 22
      A constant moving target, too much churn
    • 20
      Horribly inconsistent
    • 15
      Javascript is the New PHP
    • 9
      No ability to monitor memory utilitization
    • 8
      Shows Zero output in case of ANY error
    • 7
      Thinks strange results are better than errors
    • 6
      Can be ugly
    • 3
      No GitHub
    • 2
      Slow

    related JavaScript posts

    Zach Holman

    Oof. I have truly hated JavaScript for a long time. Like, for over twenty years now. Like, since the Clinton administration. It's always been a nightmare to deal with all of the aspects of that silly language.

    But wowza, things have changed. Tooling is just way, way better. I'm primarily web-oriented, and using React and Apollo together the past few years really opened my eyes to building rich apps. And I deeply apologize for using the phrase rich apps; I don't think I've ever said such Enterprisey words before.

    But yeah, things are different now. I still love Rails, and still use it for a lot of apps I build. But it's that silly rich apps phrase that's the problem. Users have way more comprehensive expectations than they did even five years ago, and the JS community does a good job at building tools and tech that tackle the problems of making heavy, complicated UI and frontend work.

    Obviously there's a lot of things happening here, so just saying "JavaScript isn't terrible" might encompass a huge amount of libraries and frameworks. But if you're like me, yeah, give things another shot- I'm somehow not hating on JavaScript anymore and... gulp... I kinda love it.

    See more
    Conor Myhrvold
    Tech Brand Mgr, Office of CTO at Uber · | 44 upvotes · 10.2M views

    How Uber developed the open source, end-to-end distributed tracing Jaeger , now a CNCF project:

    Distributed tracing is quickly becoming a must-have component in the tools that organizations use to monitor their complex, microservice-based architectures. At Uber, our open source distributed tracing system Jaeger saw large-scale internal adoption throughout 2016, integrated into hundreds of microservices and now recording thousands of traces every second.

    Here is the story of how we got here, from investigating off-the-shelf solutions like Zipkin, to why we switched from pull to push architecture, and how distributed tracing will continue to evolve:

    https://eng.uber.com/distributed-tracing/

    (GitHub Pages : https://www.jaegertracing.io/, GitHub: https://github.com/jaegertracing/jaeger)

    Bindings/Operator: Python Java Node.js Go C++ Kubernetes JavaScript OpenShift C# Apache Spark

    See more
    Git logo

    Git

    290.3K
    174.4K
    6.6K
    Fast, scalable, distributed revision control system
    290.3K
    174.4K
    + 1
    6.6K
    PROS OF GIT
    • 1.4K
      Distributed version control system
    • 1.1K
      Efficient branching and merging
    • 959
      Fast
    • 845
      Open source
    • 726
      Better than svn
    • 368
      Great command-line application
    • 306
      Simple
    • 291
      Free
    • 232
      Easy to use
    • 222
      Does not require server
    • 27
      Distributed
    • 22
      Small & Fast
    • 18
      Feature based workflow
    • 15
      Staging Area
    • 13
      Most wide-spread VSC
    • 11
      Role-based codelines
    • 11
      Disposable Experimentation
    • 7
      Frictionless Context Switching
    • 6
      Data Assurance
    • 5
      Efficient
    • 4
      Just awesome
    • 3
      Github integration
    • 3
      Easy branching and merging
    • 2
      Compatible
    • 2
      Flexible
    • 2
      Possible to lose history and commits
    • 1
      Rebase supported natively; reflog; access to plumbing
    • 1
      Light
    • 1
      Team Integration
    • 1
      Fast, scalable, distributed revision control system
    • 1
      Easy
    • 1
      Flexible, easy, Safe, and fast
    • 1
      CLI is great, but the GUI tools are awesome
    • 1
      It's what you do
    • 0
      Phinx
    CONS OF GIT
    • 16
      Hard to learn
    • 11
      Inconsistent command line interface
    • 9
      Easy to lose uncommitted work
    • 7
      Worst documentation ever possibly made
    • 5
      Awful merge handling
    • 3
      Unexistent preventive security flows
    • 3
      Rebase hell
    • 2
      When --force is disabled, cannot rebase
    • 2
      Ironically even die-hard supporters screw up badly
    • 1
      Doesn't scale for big data

    related Git posts

    Simon Reymann
    Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 9.3M views

    Our whole DevOps stack consists of the following tools:

    • GitHub (incl. GitHub Pages/Markdown for Documentation, GettingStarted and HowTo's) for collaborative review and code management tool
    • Respectively Git as revision control system
    • SourceTree as Git GUI
    • Visual Studio Code as IDE
    • CircleCI for continuous integration (automatize development process)
    • Prettier / TSLint / ESLint as code linter
    • SonarQube as quality gate
    • Docker as container management (incl. Docker Compose for multi-container application management)
    • VirtualBox for operating system simulation tests
    • Kubernetes as cluster management for docker containers
    • Heroku for deploying in test environments
    • nginx as web server (preferably used as facade server in production environment)
    • SSLMate (using OpenSSL) for certificate management
    • Amazon EC2 (incl. Amazon S3) for deploying in stage (production-like) and production environments
    • PostgreSQL as preferred database system
    • Redis as preferred in-memory database/store (great for caching)

    The main reason we have chosen Kubernetes over Docker Swarm is related to the following artifacts:

    • Key features: Easy and flexible installation, Clear dashboard, Great scaling operations, Monitoring is an integral part, Great load balancing concepts, Monitors the condition and ensures compensation in the event of failure.
    • Applications: An application can be deployed using a combination of pods, deployments, and services (or micro-services).
    • Functionality: Kubernetes as a complex installation and setup process, but it not as limited as Docker Swarm.
    • Monitoring: It supports multiple versions of logging and monitoring when the services are deployed within the cluster (Elasticsearch/Kibana (ELK), Heapster/Grafana, Sysdig cloud integration).
    • Scalability: All-in-one framework for distributed systems.
    • Other Benefits: Kubernetes is backed by the Cloud Native Computing Foundation (CNCF), huge community among container orchestration tools, it is an open source and modular tool that works with any OS.
    See more
    Tymoteusz Paul
    Devops guy at X20X Development LTD · | 23 upvotes · 8.3M 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
    GitHub logo

    GitHub

    279.9K
    244.2K
    10.3K
    Powerful collaboration, review, and code management for open source and private development projects
    279.9K
    244.2K
    + 1
    10.3K
    PROS OF GITHUB
    • 1.8K
      Open source friendly
    • 1.5K
      Easy source control
    • 1.3K
      Nice UI
    • 1.1K
      Great for team collaboration
    • 867
      Easy setup
    • 504
      Issue tracker
    • 486
      Great community
    • 482
      Remote team collaboration
    • 451
      Great way to share
    • 442
      Pull request and features planning
    • 147
      Just works
    • 132
      Integrated in many tools
    • 121
      Free Public Repos
    • 116
      Github Gists
    • 112
      Github pages
    • 83
      Easy to find repos
    • 62
      Open source
    • 60
      It's free
    • 60
      Easy to find projects
    • 56
      Network effect
    • 49
      Extensive API
    • 43
      Organizations
    • 42
      Branching
    • 34
      Developer Profiles
    • 32
      Git Powered Wikis
    • 30
      Great for collaboration
    • 24
      It's fun
    • 23
      Clean interface and good integrations
    • 22
      Community SDK involvement
    • 20
      Learn from others source code
    • 16
      Because: Git
    • 14
      It integrates directly with Azure
    • 10
      Standard in Open Source collab
    • 10
      Newsfeed
    • 8
      It integrates directly with Hipchat
    • 8
      Fast
    • 8
      Beautiful user experience
    • 7
      Easy to discover new code libraries
    • 6
      Smooth integration
    • 6
      Cloud SCM
    • 6
      Nice API
    • 6
      Graphs
    • 6
      Integrations
    • 6
      It's awesome
    • 5
      Quick Onboarding
    • 5
      Reliable
    • 5
      Remarkable uptime
    • 5
      CI Integration
    • 5
      Hands down best online Git service available
    • 4
      Uses GIT
    • 4
      Version Control
    • 4
      Simple but powerful
    • 4
      Unlimited Public Repos at no cost
    • 4
      Free HTML hosting
    • 4
      Security options
    • 4
      Loved by developers
    • 4
      Easy to use and collaborate with others
    • 3
      Ci
    • 3
      IAM
    • 3
      Nice to use
    • 3
      Easy deployment via SSH
    • 2
      Easy to use
    • 2
      Leads the copycats
    • 2
      All in one development service
    • 2
      Free private repos
    • 2
      Free HTML hostings
    • 2
      Easy and efficient maintainance of the projects
    • 2
      Beautiful
    • 2
      Easy source control and everything is backed up
    • 2
      IAM integration
    • 2
      Very Easy to Use
    • 2
      Good tools support
    • 2
      Issues tracker
    • 2
      Never dethroned
    • 2
      Self Hosted
    • 1
      Dasf
    • 1
      Profound
    CONS OF GITHUB
    • 53
      Owned by micrcosoft
    • 37
      Expensive for lone developers that want private repos
    • 15
      Relatively slow product/feature release cadence
    • 10
      API scoping could be better
    • 8
      Only 3 collaborators for private repos
    • 3
      Limited featureset for issue management
    • 2
      GitHub Packages does not support SNAPSHOT versions
    • 2
      Does not have a graph for showing history like git lens
    • 1
      No multilingual interface
    • 1
      Takes a long time to commit
    • 1
      Expensive

    related GitHub posts

    Johnny Bell

    I was building a personal project that I needed to store items in a real time database. I am more comfortable with my Frontend skills than my backend so I didn't want to spend time building out anything in Ruby or Go.

    I stumbled on Firebase by #Google, and it was really all I needed. It had realtime data, an area for storing file uploads and best of all for the amount of data I needed it was free!

    I built out my application using tools I was familiar with, React for the framework, Redux.js to manage my state across components, and styled-components for the styling.

    Now as this was a project I was just working on in my free time for fun I didn't really want to pay for hosting. I did some research and I found Netlify. I had actually seen them at #ReactRally the year before and deployed a Gatsby site to Netlify already.

    Netlify was very easy to setup and link to my GitHub account you select a repo and pretty much with very little configuration you have a live site that will deploy every time you push to master.

    With the selection of these tools I was able to build out my application, connect it to a realtime database, and deploy to a live environment all with $0 spent.

    If you're looking to build out a small app I suggest giving these tools a go as you can get your idea out into the real world for absolutely no cost.

    See more
    Russel Werner
    Lead Engineer at StackShare · | 32 upvotes · 2.2M views

    StackShare Feed is built entirely with React, Glamorous, and Apollo. One of our objectives with the public launch of the Feed was to enable a Server-side rendered (SSR) experience for our organic search traffic. When you visit the StackShare Feed, and you aren't logged in, you are delivered the Trending feed experience. We use an in-house Node.js rendering microservice to generate this HTML. This microservice needs to run and serve requests independent of our Rails web app. Up until recently, we had a mono-repo with our Rails and React code living happily together and all served from the same web process. In order to deploy our SSR app into a Heroku environment, we needed to split out our front-end application into a separate repo in GitHub. The driving factor in this decision was mostly due to limitations imposed by Heroku specifically with how processes can't communicate with each other. A new SSR app was created in Heroku and linked directly to the frontend repo so it stays in-sync with changes.

    Related to this, we need a way to "deploy" our frontend changes to various server environments without building & releasing the entire Ruby application. We built a hybrid Amazon S3 Amazon CloudFront solution to host our Webpack bundles. A new CircleCI script builds the bundles and uploads them to S3. The final step in our rollout is to update some keys in Redis so our Rails app knows which bundles to serve. The result of these efforts were significant. Our frontend team now moves independently of our backend team, our build & release process takes only a few minutes, we are now using an edge CDN to serve JS assets, and we have pre-rendered React pages!

    #StackDecisionsLaunch #SSR #Microservices #FrontEndRepoSplit

    See more