Alternatives to WebAssembly logo

Alternatives to WebAssembly

JavaScript, Golang, Emscripten, React, and Java are the most popular alternatives and competitors to WebAssembly.
218
215
+ 1
0

What is WebAssembly and what are its top alternatives?

WebAssembly is a low-level bytecode format that runs in web browsers as a compilation target for programming languages. It allows developers to write code in languages like C, C++, and Rust, and run them in the browser at near-native speeds. WebAssembly improves the performance of web applications and enables developers to use existing codebases for web development. However, WebAssembly has limitations in terms of debugging and tooling support compared to traditional web development technologies.

  1. asm.js: asm.js is a subset of JavaScript that can be used to run performance-sensitive code in web browsers. It aims to deliver near-native performance by using static types and constraints to allow advanced optimizations in JavaScript engines. The pros of asm.js include widespread support in browsers and ease of integration with existing web applications, but the cons include limited optimization opportunities compared to WebAssembly.
  2. Emscripten: Emscripten is a compiler toolchain that translates C/C++ code to WebAssembly or asm.js. It allows developers to reuse existing codebases written in C/C++ for web development, providing a seamless transition to the web platform. The key features of Emscripten include compatibility with standard C/C++ libraries, but it requires additional setup and configuration compared to direct WebAssembly development.
  3. PNaCl (Portable Native Client): PNaCl is a sandboxing technology that enables running native code in web browsers with high performance and security. It allows developers to write code in C/C++ and compile it to a portable binary format that can be executed within the browser. The pros of PNaCl include close-to-native performance and security guarantees, but the cons include limited browser support and complexity in deployment.
  4. Cheerp: Cheerp is a C/C++ to JavaScript/WebAssembly compiler that aims to provide high performance and seamless integration of native code with web applications. It allows developers to leverage existing C/C++ codebases for web development, eliminating the need for manual porting. The key features of Cheerp include efficient code generation and optimization, but it may have limitations in terms of compatibility with complex C/C++ features.
  5. Blazor: Blazor is a framework for building interactive web UIs using C# instead of JavaScript. It allows developers to write client-side code in C# and run it in the browser using WebAssembly. The pros of Blazor include seamless integration with .NET ecosystem and familiar language for developers, while the cons include potential performance overhead compared to JavaScript-based solutions.
  6. Kotlin/JS: Kotlin/JS is a language and compiler that allows developers to target JavaScript and WebAssembly platforms. It provides interoperability with JavaScript libraries and frameworks, making it easy to integrate Kotlin code into web applications. The key features of Kotlin/JS include modern language features and tooling support, but it may have a steeper learning curve for developers new to the language.
  7. GNU Guile: GNU Guile is a Scheme implementation that can compile to JavaScript or WebAssembly, enabling functional programming in web development. It offers a powerful and expressive language for building web applications, with seamless integration of Scheme code into existing JavaScript projects. The pros of GNU Guile include flexibility and extensibility, but the cons may include limited adoption and community support compared to mainstream alternatives.
  8. SwiftWasm: SwiftWasm is a port of the Swift programming language to WebAssembly, enabling developers to write web applications in Swift. It provides a familiar syntax and performance benefits of WebAssembly, allowing for rapid development of web projects. The key features of SwiftWasm include type safety and modern language features, but the cons may include limited tooling and library support compared to established web development technologies.
  9. AssemblyScript: AssemblyScript is a TypeScript-like language that compiles to WebAssembly, offering a familiar syntax for web developers. It provides a smooth transition from TypeScript to WebAssembly, enabling developers to write high-performance code for the web platform. The pros of AssemblyScript include TypeScript compatibility and ease of use, but the cons may include limited language features compared to traditional programming languages.
  10. Haxe: Haxe is a cross-platform language that can target JavaScript, WebAssembly, and other platforms, providing flexibility for web development. It allows developers to write code once and deploy it to multiple platforms, reducing development time and effort. The key features of Haxe include cross-platform compatibility and extensive standard library, but the cons may include performance overhead compared to lower-level languages like C/C++.

Top Alternatives to WebAssembly

  • 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. ...

  • Golang
    Golang

    Go is expressive, concise, clean, and efficient. Its concurrency mechanisms make it easy to write programs that get the most out of multicore and networked machines, while its novel type system enables flexible and modular program construction. Go compiles quickly to machine code yet has the convenience of garbage collection and the power of run-time reflection. It's a fast, statically typed, compiled language that feels like a dynamically typed, interpreted language. ...

  • Emscripten
    Emscripten

    This allows applications and libraries originally designed to run as standard executables to be integrated into client side web applications. ...

  • React
    React

    Lots of people use React as the V in MVC. Since React makes no assumptions about the rest of your technology stack, it's easy to try it out on a small feature in an existing project. ...

  • Java
    Java

    Java is a programming language and computing platform first released by Sun Microsystems in 1995. There are lots of applications and websites that will not work unless you have Java installed, and more are created every day. Java is fast, secure, and reliable. From laptops to datacenters, game consoles to scientific supercomputers, cell phones to the Internet, Java is everywhere! ...

  • WebGL
    WebGL

    It is integrated completely into all the web standards of the browser allowing GPU accelerated usage of physics and image processing and effects as part of the web page canvas. Its elements can be mixed with other HTML elements. ...

  • Docker
    Docker

    The Docker Platform is the industry-leading container platform for continuous, high-velocity innovation, enabling organizations to seamlessly build and share any application — from legacy to what comes next — and securely run them anywhere ...

  • 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. ...

WebAssembly alternatives & related posts

JavaScript logo

JavaScript

354.8K
269.8K
8.1K
Lightweight, interpreted, object-oriented language with first-class functions
354.8K
269.8K
+ 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
    Everyone use it
  • 9
    Expansive community
  • 9
    Easy
  • 9
    Can be used in backend, frontend and DB
  • 8
    Easy to hire developers
  • 8
    No need to use PHP
  • 8
    For the good parts
  • 8
    Can be used both as frontend and backend as well
  • 8
    Powerful
  • 8
    Most Popular Language in the World
  • 7
    Evolution of C
  • 7
    Hard not to use
  • 7
    Versitile
  • 7
    Its fun and fast
  • 7
    Supports lambdas and closures
  • 7
    Love-hate relationship
  • 7
    Photoshop has 3 JS runtimes built in
  • 7
    Nice
  • 7
    It's fun
  • 7
    Popularized Class-Less Architecture & Lambdas
  • 7
    Agile, packages simple to use
  • 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
    It let's me use Babel & Typescript
  • 6
    Easy to make something
  • 5
    Client processing
  • 5
    Everywhere
  • 5
    Scope manipulation
  • 5
    Function expressions are useful for callbacks
  • 5
    Stockholm Syndrome
  • 5
    Promise relationship
  • 5
    Clojurescript
  • 5
    What to add
  • 4
    Only Programming language on browser
  • 4
    Because it is so simple and lightweight
  • 1
    Easy to understand
  • 1
    Test
  • 1
    Test2
  • 1
    Subskill #4
  • 1
    Easy to learn
  • 1
    Hard to learn
  • 1
    Not the best
  • 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
  • 0
    HORRIBLE DOCUMENTS, faulty code, repo has bugs

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 · 11.3M 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
Golang logo

Golang

22.3K
13.7K
3.3K
An open source programming language that makes it easy to build simple, reliable, and efficient software
22.3K
13.7K
+ 1
3.3K
PROS OF GOLANG
  • 548
    High-performance
  • 395
    Simple, minimal syntax
  • 363
    Fun to write
  • 301
    Easy concurrency support via goroutines
  • 273
    Fast compilation times
  • 193
    Goroutines
  • 180
    Statically linked binaries that are simple to deploy
  • 150
    Simple compile build/run procedures
  • 136
    Backed by google
  • 136
    Great community
  • 53
    Garbage collection built-in
  • 45
    Built-in Testing
  • 44
    Excellent tools - gofmt, godoc etc
  • 39
    Elegant and concise like Python, fast like C
  • 37
    Awesome to Develop
  • 26
    Used for Docker
  • 25
    Flexible interface system
  • 24
    Deploy as executable
  • 24
    Great concurrency pattern
  • 20
    Open-source Integration
  • 18
    Easy to read
  • 17
    Fun to write and so many feature out of the box
  • 16
    Go is God
  • 14
    Easy to deploy
  • 14
    Powerful and simple
  • 14
    Its Simple and Heavy duty
  • 13
    Best language for concurrency
  • 13
    Concurrency
  • 11
    Rich standard library
  • 11
    Safe GOTOs
  • 10
    Clean code, high performance
  • 10
    Easy setup
  • 9
    High performance
  • 9
    Simplicity, Concurrency, Performance
  • 8
    Hassle free deployment
  • 8
    Single binary avoids library dependency issues
  • 7
    Gofmt
  • 7
    Cross compiling
  • 7
    Simple, powerful, and great performance
  • 7
    Used by Giants of the industry
  • 6
    Garbage Collection
  • 5
    Very sophisticated syntax
  • 5
    Excellent tooling
  • 5
    WYSIWYG
  • 4
    Keep it simple and stupid
  • 4
    Widely used
  • 4
    Kubernetes written on Go
  • 2
    No generics
  • 1
    Operator goto
  • 1
    Looks not fancy, but promoting pragmatic idioms
CONS OF GOLANG
  • 42
    You waste time in plumbing code catching errors
  • 25
    Verbose
  • 23
    Packages and their path dependencies are braindead
  • 16
    Google's documentations aren't beginer friendly
  • 15
    Dependency management when working on multiple projects
  • 10
    Automatic garbage collection overheads
  • 8
    Uncommon syntax
  • 7
    Type system is lacking (no generics, etc)
  • 5
    Collection framework is lacking (list, set, map)
  • 3
    Best programming language
  • 1
    A failed experiment to combine c and python

related Golang posts

Conor Myhrvold
Tech Brand Mgr, Office of CTO at Uber · | 44 upvotes · 11.3M 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
Nick Parsons
Building cool things on the internet 🛠️ at Stream · | 35 upvotes · 4M views

Winds 2.0 is an open source Podcast/RSS reader developed by Stream with a core goal to enable a wide range of developers to contribute.

We chose JavaScript because nearly every developer knows or can, at the very least, read JavaScript. With ES6 and Node.js v10.x.x, it’s become a very capable language. Async/Await is powerful and easy to use (Async/Await vs Promises). Babel allows us to experiment with next-generation JavaScript (features that are not in the official JavaScript spec yet). Yarn allows us to consistently install packages quickly (and is filled with tons of new tricks)

We’re using JavaScript for everything – both front and backend. Most of our team is experienced with Go and Python, so Node was not an obvious choice for this app.

Sure... there will be haters who refuse to acknowledge that there is anything remotely positive about JavaScript (there are even rants on Hacker News about Node.js); however, without writing completely in JavaScript, we would not have seen the results we did.

#FrameworksFullStack #Languages

See more
Emscripten logo

Emscripten

18
20
0
An Open Source LLVM to JavaScript compiler
18
20
+ 1
0
PROS OF EMSCRIPTEN
    Be the first to leave a pro
    CONS OF EMSCRIPTEN
      Be the first to leave a con

      related Emscripten posts

      React logo

      React

      170.6K
      140.9K
      4.1K
      A JavaScript library for building user interfaces
      170.6K
      140.9K
      + 1
      4.1K
      PROS OF REACT
      • 830
        Components
      • 672
        Virtual dom
      • 578
        Performance
      • 508
        Simplicity
      • 442
        Composable
      • 186
        Data flow
      • 166
        Declarative
      • 128
        Isn't an mvc framework
      • 120
        Reactive updates
      • 115
        Explicit app state
      • 50
        JSX
      • 29
        Learn once, write everywhere
      • 22
        Easy to Use
      • 21
        Uni-directional data flow
      • 17
        Works great with Flux Architecture
      • 11
        Great perfomance
      • 10
        Javascript
      • 9
        Built by Facebook
      • 8
        TypeScript support
      • 6
        Server Side Rendering
      • 6
        Speed
      • 5
        Feels like the 90s
      • 5
        Excellent Documentation
      • 5
        Props
      • 5
        Functional
      • 5
        Easy as Lego
      • 5
        Closer to standard JavaScript and HTML than others
      • 5
        Cross-platform
      • 5
        Easy to start
      • 5
        Hooks
      • 5
        Awesome
      • 5
        Scalable
      • 4
        Super easy
      • 4
        Allows creating single page applications
      • 4
        Server side views
      • 4
        Sdfsdfsdf
      • 4
        Start simple
      • 4
        Strong Community
      • 4
        Fancy third party tools
      • 4
        Scales super well
      • 3
        Has arrow functions
      • 3
        Beautiful and Neat Component Management
      • 3
        Just the View of MVC
      • 3
        Simple, easy to reason about and makes you productive
      • 3
        Fast evolving
      • 3
        SSR
      • 3
        Great migration pathway for older systems
      • 3
        Rich ecosystem
      • 3
        Simple
      • 3
        Has functional components
      • 3
        Every decision architecture wise makes sense
      • 3
        Very gentle learning curve
      • 2
        Split your UI into components with one true state
      • 2
        Image upload
      • 2
        Permissively-licensed
      • 2
        Fragments
      • 2
        Sharable
      • 2
        Recharts
      • 2
        HTML-like
      • 1
        React hooks
      • 1
        Datatables
      CONS OF REACT
      • 41
        Requires discipline to keep architecture organized
      • 30
        No predefined way to structure your app
      • 29
        Need to be familiar with lots of third party packages
      • 13
        JSX
      • 10
        Not enterprise friendly
      • 6
        One-way binding only
      • 3
        State consistency with backend neglected
      • 3
        Bad Documentation
      • 2
        Error boundary is needed
      • 2
        Paradigms change too fast

      related React 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
      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
      Java logo

      Java

      133.7K
      101.2K
      3.7K
      A concurrent, class-based, object-oriented, language specifically designed to have as few implementation dependencies as possible
      133.7K
      101.2K
      + 1
      3.7K
      PROS OF JAVA
      • 599
        Great libraries
      • 445
        Widely used
      • 400
        Excellent tooling
      • 395
        Huge amount of documentation available
      • 334
        Large pool of developers available
      • 208
        Open source
      • 202
        Excellent performance
      • 157
        Great development
      • 150
        Used for android
      • 148
        Vast array of 3rd party libraries
      • 60
        Compiled Language
      • 52
        Used for Web
      • 46
        High Performance
      • 46
        Managed memory
      • 44
        Native threads
      • 43
        Statically typed
      • 35
        Easy to read
      • 33
        Great Community
      • 29
        Reliable platform
      • 24
        JVM compatibility
      • 24
        Sturdy garbage collection
      • 22
        Cross Platform Enterprise Integration
      • 20
        Good amount of APIs
      • 20
        Universal platform
      • 18
        Great Support
      • 14
        Great ecosystem
      • 11
        Lots of boilerplate
      • 11
        Backward compatible
      • 10
        Everywhere
      • 9
        Excellent SDK - JDK
      • 7
        It's Java
      • 7
        Static typing
      • 7
        Cross-platform
      • 6
        Long term language
      • 6
        Better than Ruby
      • 6
        Mature language thus stable systems
      • 6
        Portability
      • 5
        Used for Android development
      • 5
        Vast Collections Library
      • 5
        Clojure
      • 4
        Old tech
      • 4
        Best martial for design
      • 4
        Most developers favorite
      • 3
        Stable platform, which many new languages depend on
      • 3
        Testable
      • 3
        Great Structure
      • 3
        Javadoc
      • 3
        History
      • 2
        Faster than python
      • 2
        Type Safe
      • 0
        Job
      CONS OF JAVA
      • 33
        Verbosity
      • 27
        NullpointerException
      • 17
        Nightmare to Write
      • 16
        Overcomplexity is praised in community culture
      • 12
        Boiler plate code
      • 8
        Classpath hell prior to Java 9
      • 6
        No REPL
      • 4
        No property
      • 3
        Code are too long
      • 2
        Non-intuitive generic implementation
      • 2
        There is not optional parameter
      • 2
        Floating-point errors
      • 1
        Java's too statically, stronglly, and strictly typed
      • 1
        Returning Wildcard Types
      • 1
        Terrbible compared to Python/Batch Perormence

      related Java posts

      Conor Myhrvold
      Tech Brand Mgr, Office of CTO at Uber · | 44 upvotes · 11.3M 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
      Kamil Kowalski
      Lead Architect at Fresha · | 28 upvotes · 4M views

      When you think about test automation, it’s crucial to make it everyone’s responsibility (not just QA Engineers'). We started with Selenium and Java, but with our platform revolving around Ruby, Elixir and JavaScript, QA Engineers were left alone to automate tests. Cypress was the answer, as we could switch to JS and simply involve more people from day one. There's a downside too, as it meant testing on Chrome only, but that was "good enough" for us + if really needed we can always cover some specific cases in a different way.

      See more
      WebGL logo

      WebGL

      179
      200
      0
      A JavaScript API for rendering 3D graphics within any compatible web browser
      179
      200
      + 1
      0
      PROS OF WEBGL
        Be the first to leave a pro
        CONS OF WEBGL
          Be the first to leave a con

          related WebGL posts

          Shared insights
          on
          WebGLWebGLthree.jsthree.js

          I want a advice on what to use as a beginner three.js or WebGL?

          See more
          Docker logo

          Docker

          172.3K
          138.4K
          3.9K
          Enterprise Container Platform for High-Velocity Innovation.
          172.3K
          138.4K
          + 1
          3.9K
          PROS OF DOCKER
          • 823
            Rapid integration and build up
          • 691
            Isolation
          • 521
            Open source
          • 505
            Testa­bil­i­ty and re­pro­ducibil­i­ty
          • 460
            Lightweight
          • 218
            Standardization
          • 185
            Scalable
          • 106
            Upgrading / down­grad­ing / ap­pli­ca­tion versions
          • 88
            Security
          • 85
            Private paas environments
          • 34
            Portability
          • 26
            Limit resource usage
          • 17
            Game changer
          • 16
            I love the way docker has changed virtualization
          • 14
            Fast
          • 12
            Concurrency
          • 8
            Docker's Compose tools
          • 6
            Easy setup
          • 6
            Fast and Portable
          • 5
            Because its fun
          • 4
            Makes shipping to production very simple
          • 3
            Highly useful
          • 3
            It's dope
          • 2
            Very easy to setup integrate and build
          • 2
            HIgh Throughput
          • 2
            Package the environment with the application
          • 2
            Does a nice job hogging memory
          • 2
            Open source and highly configurable
          • 2
            Simplicity, isolation, resource effective
          • 2
            MacOS support FAKE
          • 2
            Its cool
          • 2
            Docker hub for the FTW
          • 2
            Super
          • 0
            Asdfd
          CONS OF DOCKER
          • 8
            New versions == broken features
          • 6
            Unreliable networking
          • 6
            Documentation not always in sync
          • 4
            Moves quickly
          • 3
            Not Secure

          related Docker posts

          Simon Reymann
          Senior Fullstack Developer at QUANTUSflow Software GmbH · | 30 upvotes · 10M 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 · 9M 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
          Git logo

          Git

          293.8K
          176K
          6.6K
          Fast, scalable, distributed revision control system
          293.8K
          176K
          + 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 · 10M 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 · 9M 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