What is Rust and what are its top alternatives?
Top Alternatives to Rust
- Swift
Writing code is interactive and fun, the syntax is concise yet expressive, and apps run lightning-fast. Swift is ready for your next iOS and OS X project — or for addition into your current app — because Swift code works side-by-side with Objective-C. ...
- Python
Python is a general purpose programming language created by Guido Van Rossum. Python is most praised for its elegant syntax and readable code, if you are just beginning your programming career python suits you best. ...
- 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. ...
- Haskell
It is a general purpose language that can be used in any domain and use case, it is ideally suited for proprietary business logic and data analysis, fast prototyping and enhancing existing software environments with correct code, performance and scalability. ...
- 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! ...
- 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 is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency. ...
Rust alternatives & related posts
- Performance68
- Low-level49
- Portability35
- Hardware level28
- Embedded apps19
- Pure13
- Performance of assembler9
- Ubiquity8
- Great for embedded6
- Old4
- Compiles quickly3
- OpenMP2
- No garbage collection to slow it down2
- Gnu/linux interoperable1
- Low-level5
- No built in support for concurrency3
- Lack of type safety2
- No built in support for parallelism (e.g. map-reduce)2
related C lang posts
Why Uber developed H3, our open source grid system to make geospatial data visualization and exploration easier and more efficient:
We decided to create H3 to combine the benefits of a hexagonal global grid system with a hierarchical indexing system. A global grid system usually requires at least two things: a map projection and a grid laid on top of the map. For map projection, we chose to use gnomonic projections centered on icosahedron faces. This projects from Earth as a sphere to an icosahedron, a twenty-sided platonic solid. The H3 grid is constructed by laying out 122 base cells over the Earth, with ten cells per face. H3 supports sixteen resolutions: https://eng.uber.com/h3/
(GitHub Pages : https://uber.github.io/h3/#/ Written in C w/ bindings in Java & JavaScript )
One important decision for delivering a platform independent solution with low memory footprint and minimal dependencies was the choice of the programming language. We considered a few from Python (there was already a reasonably large Python code base at Thumbtack), to Go (we were taking our first steps with it), and even Rust (too immature at the time).
We ended up writing it in C. It was easy to meet all requirements with only one external dependency for implementing the web server, clearly no challenges running it on any of the Linux distributions we were maintaining, and arguably the implementation with the smallest memory footprint given the choices above.
Swift
- Ios259
- Elegant180
- Not Objective-C126
- Backed by apple107
- Type inference93
- Generics61
- Playgrounds54
- Semicolon free49
- OSX38
- Tuples offer compound variables36
- Clean Syntax24
- Easy to learn24
- Open Source22
- Beautiful Code21
- Functional20
- Dynamic12
- Linux12
- Protocol-oriented programming11
- Promotes safe, readable code10
- No S-l-o-w JVM9
- Explicit optionals8
- Storyboard designer7
- Optionals6
- Type safety6
- Super addicting language, great people, open, elegant5
- Best UI concept5
- Its friendly4
- Highly Readable codes4
- Fail-safe4
- Powerful4
- Faster and looks better4
- Swift is faster than Objective-C4
- Feels like a better C++4
- Easy to learn and work3
- Much more fun3
- Protocol extensions3
- Native3
- Its fun and damn fast3
- Strong Type safety3
- Easy to Maintain3
- Protocol as type2
- All Cons C# and Java Swift Already has2
- Esay2
- MacOS2
- Type Safe2
- Protocol oriented programming2
- Can interface with C easily1
- Actually don't have to own a mac1
- Free from Memory Leak1
- Swift is easier to understand for non-iOS developers.1
- Numbers with underbar1
- Optional chain1
- Great for Multi-Threaded Programming1
- Runs Python 8 times faster1
- Objec1
- Must own a mac5
- Memory leaks are not uncommon2
- Very irritatingly picky about things that’s1
- Complicated process for exporting modules1
- Its classes compile to roughly 300 lines of assembly1
- Is a lot more effort than lua to make simple functions1
- Overly complex options makes it easy to create bad code0
related Swift posts
Hi Community! Trust everyone is keeping safe. I am exploring the idea of building a #Neobank (App) with end-to-end banking capabilities. In the process of exploring this space, I have come across multiple Apps (N26, Revolut, Monese, etc) and explored their stacks in detail. The confusion remains to be the Backend Tech to be used?
What would you go with considering all of the languages such as Node.js Java Rails Python are suggested by some person or the other. As a general trend, I have noticed the usage of Node with React on the front or Node with a combination of Kotlin and Swift. Please suggest what would be the right approach!
Excerpts from how we developed (and subsequently open sourced) Uber's cross-platform mobile architecture framework, RIBs , going from Objective-C to Swift in the process for iOS: https://github.com/uber/RIBs
Uber’s new application architecture (RIBs) extensively uses protocols to keep its various components decoupled and testable. We used this architecture for the first time in our new rider application and moved our primary language from Objective-C to Swift. Since Swift is a very static language, unit testing became problematic. Dynamic languages have good frameworks to build test mocks, stubs, or stand-ins by dynamically creating or modifying existing concrete classes.
Needless to say, we were not very excited about the additional complexity of manually writing and maintaining mock implementations for each of our thousands of protocols.
The information required to generate mock classes already exists in the Swift protocol. For Uber’s use case, we set out to create tooling that would let engineers automatically generate test mocks for any protocol they wanted by simply annotating them.
The iOS codebase for our rider application alone incorporates around 1,500 of these generated mocks. Without our code generation tool, all of these would have to be written and maintained by hand, which would have made testing much more time-intensive. Auto-generated mocks have contributed a lot to the unit test coverage that we have today.
We built these code generation tools ourselves for a number of reasons, including that there weren’t many open source tools available at the time we started our effort. Today, there are some great open source tools to generate resource accessors, like SwiftGen. And Sourcery can help you with generic code generation needs:
https://eng.uber.com/code-generation/ https://eng.uber.com/driver-app-ribs-architecture/
(GitHub : https://github.com/uber/RIBs )
Python
- Great libraries1.2K
- Readable code961
- Beautiful code846
- Rapid development787
- Large community689
- Open source435
- Elegant393
- Great community282
- Object oriented272
- Dynamic typing220
- Great standard library77
- Very fast59
- Functional programming55
- Easy to learn49
- Scientific computing45
- Great documentation35
- Productivity29
- Easy to read28
- Matlab alternative28
- Simple is better than complex23
- It's the way I think20
- Imperative19
- Free18
- Very programmer and non-programmer friendly18
- Powerfull language17
- Machine learning support17
- Fast and simple16
- Scripting14
- Explicit is better than implicit12
- Ease of development11
- Clear and easy and powerfull10
- Unlimited power9
- It's lean and fun to code8
- Import antigravity8
- Print "life is short, use python"7
- Python has great libraries for data processing7
- Although practicality beats purity6
- Flat is better than nested6
- Great for tooling6
- Rapid Prototyping6
- Readability counts6
- High Documented language6
- I love snakes6
- Fast coding and good for competitions6
- There should be one-- and preferably only one --obvious6
- Now is better than never6
- Great for analytics5
- Lists, tuples, dictionaries5
- Easy to learn and use4
- Simple and easy to learn4
- Easy to setup and run smooth4
- Web scraping4
- CG industry needs4
- Socially engaged community4
- Complex is better than complicated4
- Multiple Inheritence4
- Beautiful is better than ugly4
- Plotting4
- If the implementation is hard to explain, it's a bad id3
- Special cases aren't special enough to break the rules3
- Pip install everything3
- List comprehensions3
- No cruft3
- Generators3
- Import this3
- It is Very easy , simple and will you be love programmi3
- Many types of collections3
- If the implementation is easy to explain, it may be a g3
- Batteries included2
- Should START with this but not STICK with This2
- Powerful language for AI2
- Can understand easily who are new to programming2
- Flexible and easy2
- Good for hacking2
- A-to-Z2
- Because of Netflix2
- Only one way to do it2
- Better outcome2
- Sexy af1
- Slow1
- Securit1
- Ni0
- Powerful0
- Still divided between python 2 and python 353
- Performance impact28
- Poor syntax for anonymous functions26
- GIL22
- Package management is a mess19
- Too imperative-oriented14
- Hard to understand12
- Dynamic typing12
- Very slow12
- Indentations matter a lot8
- Not everything is expression8
- Incredibly slow7
- Explicit self parameter in methods7
- Requires C functions for dynamic modules6
- Poor DSL capabilities6
- No anonymous functions6
- Fake object-oriented programming5
- Threading5
- The "lisp style" whitespaces5
- Official documentation is unclear.5
- Hard to obfuscate5
- Circular import5
- Lack of Syntax Sugar leads to "the pyramid of doom"4
- The benevolent-dictator-for-life quit4
- Not suitable for autocomplete4
- Meta classes2
- Training wheels (forced indentation)1
related Python posts
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
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
Golang
- High-performance548
- Simple, minimal syntax395
- Fun to write363
- Easy concurrency support via goroutines301
- Fast compilation times273
- Goroutines193
- Statically linked binaries that are simple to deploy180
- Simple compile build/run procedures150
- Backed by google136
- Great community136
- Garbage collection built-in53
- Built-in Testing45
- Excellent tools - gofmt, godoc etc44
- Elegant and concise like Python, fast like C39
- Awesome to Develop37
- Used for Docker26
- Flexible interface system25
- Deploy as executable24
- Great concurrency pattern24
- Open-source Integration20
- Easy to read18
- Fun to write and so many feature out of the box17
- Go is God16
- Easy to deploy14
- Powerful and simple14
- Its Simple and Heavy duty14
- Best language for concurrency13
- Concurrency13
- Rich standard library11
- Safe GOTOs11
- Clean code, high performance10
- Easy setup10
- High performance9
- Simplicity, Concurrency, Performance9
- Hassle free deployment8
- Single binary avoids library dependency issues8
- Gofmt7
- Cross compiling7
- Simple, powerful, and great performance7
- Used by Giants of the industry7
- Garbage Collection6
- Very sophisticated syntax5
- Excellent tooling5
- WYSIWYG5
- Keep it simple and stupid4
- Widely used4
- Kubernetes written on Go4
- No generics2
- Operator goto1
- Looks not fancy, but promoting pragmatic idioms1
- You waste time in plumbing code catching errors42
- Verbose25
- Packages and their path dependencies are braindead23
- Google's documentations aren't beginer friendly16
- Dependency management when working on multiple projects15
- Automatic garbage collection overheads10
- Uncommon syntax8
- Type system is lacking (no generics, etc)7
- Collection framework is lacking (list, set, map)5
- Best programming language3
- A failed experiment to combine c and python1
related Golang posts
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
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
- Purely-functional programming90
- Statically typed66
- Type-safe59
- Open source39
- Great community38
- Built-in concurrency31
- Built-in parallelism30
- Composable30
- Referentially transparent24
- Generics20
- Type inference15
- Intellectual satisfaction15
- If it compiles, it's correct12
- Flexible8
- Monads8
- Great type system5
- Proposition testing with QuickCheck4
- One of the most powerful languages *(see blub paradox)*4
- Purely-functional Programming4
- Highly expressive, type-safe, fast development time3
- Pattern matching and completeness checking3
- Great maintainability of the code3
- Fun3
- Reliable3
- Best in class thinking tool2
- Kind system2
- Better type-safe than sorry2
- Type classes2
- Predictable1
- Orthogonality1
- Too much distraction in language extensions9
- Error messages can be very confusing8
- Libraries have poor documentation5
- No good ABI3
- No best practices3
- Poor packaging for apps written in it for Linux distros2
- Sometimes performance is unpredictable2
- Slow compilation1
- Monads are hard to understand1
related Haskell posts
In early 2015, Uber Engineering migrated its business entities from integer identifiers to UUID identifiers as part of an initiative focused on using multiple active data centers. To do that, Uber engineers had to identify foreign key relationships between every table in the data warehouse—a nontrivial task by any accounting.
Uber’s solution was to observe and analyze incoming SQL queries to extract foreign key relationships, for which it built tool called Queryparser, which it open sourced.)
Queryparser is written in Haskell, a tool that the team wasn’t previously familiar with but has strong support for language parsing. To help each other get up to speed, engineers started a weekly reading group to discuss Haskell books and documentation.
Why I am using Haskell in my free time?
I have 3 reasons for it. I am looking for:
Fun.
Improve functional programming skill.
Improve problem-solving skill.
Laziness and mathematical abstractions behind Haskell makes it a wonderful language.
It is Pure functional, it helps me to write better Scala code.
Highly expressive language gives elegant ways to solve coding puzzle.
Java
- Great libraries599
- Widely used445
- Excellent tooling400
- Huge amount of documentation available395
- Large pool of developers available334
- Open source208
- Excellent performance202
- Great development157
- Used for android150
- Vast array of 3rd party libraries148
- Compiled Language60
- Used for Web52
- High Performance46
- Managed memory46
- Native threads44
- Statically typed43
- Easy to read35
- Great Community33
- Reliable platform29
- Sturdy garbage collection24
- JVM compatibility24
- Cross Platform Enterprise Integration22
- Universal platform20
- Good amount of APIs20
- Great Support18
- Great ecosystem14
- Backward compatible11
- Lots of boilerplate11
- Everywhere10
- Excellent SDK - JDK9
- It's Java7
- Cross-platform7
- Static typing7
- Mature language thus stable systems6
- Better than Ruby6
- Long term language6
- Portability6
- Clojure5
- Vast Collections Library5
- Used for Android development5
- Most developers favorite4
- Old tech4
- History3
- Great Structure3
- Stable platform, which many new languages depend on3
- Javadoc3
- Testable3
- Best martial for design3
- Type Safe2
- Faster than python2
- Job0
- Verbosity33
- NullpointerException27
- Nightmare to Write17
- Overcomplexity is praised in community culture16
- Boiler plate code12
- Classpath hell prior to Java 98
- No REPL6
- No property4
- Code are too long3
- Non-intuitive generic implementation2
- There is not optional parameter2
- Floating-point errors2
- Java's too statically, stronglly, and strictly typed1
- Returning Wildcard Types1
- Terrbible compared to Python/Batch Perormence1
related Java posts
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
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.
JavaScript
- Can be used on frontend/backend1.7K
- It's everywhere1.5K
- Lots of great frameworks1.2K
- Fast896
- Light weight745
- Flexible425
- You can't get a device today that doesn't run js392
- Non-blocking i/o286
- Ubiquitousness236
- Expressive191
- Extended functionality to web pages55
- Relatively easy language49
- Executed on the client side46
- Relatively fast to the end user30
- Pure Javascript25
- Functional programming21
- Async15
- Full-stack13
- Setup is easy12
- Its everywhere12
- Future Language of The Web12
- JavaScript is the New PHP11
- Because I love functions11
- Like it or not, JS is part of the web standard10
- Expansive community9
- Everyone use it9
- Can be used in backend, frontend and DB9
- Easy9
- Easy to hire developers8
- No need to use PHP8
- For the good parts8
- Can be used both as frontend and backend as well8
- Powerful8
- Most Popular Language in the World8
- Popularized Class-Less Architecture & Lambdas7
- It's fun7
- Nice7
- Versitile7
- Hard not to use7
- Its fun and fast7
- Agile, packages simple to use7
- Supports lambdas and closures7
- Love-hate relationship7
- Photoshop has 3 JS runtimes built in7
- Evolution of C7
- 1.6K Can be used on frontend/backend6
- Client side JS uses the visitors CPU to save Server Res6
- It let's me use Babel & Typescript6
- Easy to make something6
- Can be used on frontend/backend/Mobile/create PRO Ui6
- Promise relationship5
- Stockholm Syndrome5
- Function expressions are useful for callbacks5
- Scope manipulation5
- Everywhere5
- Client processing5
- Clojurescript5
- What to add5
- Because it is so simple and lightweight4
- Only Programming language on browser4
- Test21
- Easy to learn1
- Easy to understand1
- Not the best1
- Hard to learn1
- Subskill #41
- Test1
- Hard 彤0
- A constant moving target, too much churn22
- Horribly inconsistent20
- Javascript is the New PHP15
- No ability to monitor memory utilitization9
- Shows Zero output in case of ANY error8
- Thinks strange results are better than errors7
- Can be ugly6
- No GitHub3
- Slow2
related JavaScript posts
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.
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
- Distributed version control system1.4K
- Efficient branching and merging1.1K
- Fast959
- Open source845
- Better than svn726
- Great command-line application368
- Simple306
- Free291
- Easy to use232
- Does not require server222
- Distributed27
- Small & Fast22
- Feature based workflow18
- Staging Area15
- Most wide-spread VSC13
- Role-based codelines11
- Disposable Experimentation11
- Frictionless Context Switching7
- Data Assurance6
- Efficient5
- Just awesome4
- Github integration3
- Easy branching and merging3
- Compatible2
- Flexible2
- Possible to lose history and commits2
- Rebase supported natively; reflog; access to plumbing1
- Light1
- Team Integration1
- Fast, scalable, distributed revision control system1
- Easy1
- Flexible, easy, Safe, and fast1
- CLI is great, but the GUI tools are awesome1
- It's what you do1
- Phinx0
- Hard to learn16
- Inconsistent command line interface11
- Easy to lose uncommitted work9
- Worst documentation ever possibly made7
- Awful merge handling5
- Unexistent preventive security flows3
- Rebase hell3
- When --force is disabled, cannot rebase2
- Ironically even die-hard supporters screw up badly2
- Doesn't scale for big data1
related Git posts
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.
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.