Git

Git

DevOps / Build, Test, Deploy / Version Control System

Decision about Prettier, Git, Magento, Sublime Text, PhpStorm, Visual Studio Code, PHP, Frontend

Avatar of johnnyxbell
Sr. Software Engineer at StackShare ·
PrettierPrettier
GitGit
MagentoMagento
Sublime TextSublime Text
PhpStormPhpStorm
Visual Studio CodeVisual Studio Code
#PHP
#Frontend

I've been in the #frontend game for about 7 years now. I started coding in Sublime Text because all of the tutorials I was doing back then everyone was using it. I found the speed amazing compared to some other tools at the time. I kept using Sublime Text for about 4-5 years.

I find Sublime Text lacks some functionality, after all it is just a text editor rather than a full fledged IDE. I finally converted over to PhpStorm as I was working with Magento and Magento as you know is mainly #PHP based.

This was amazing all the features in PhpStorm I loved, the debugging features, and the control click feature when you click on a dependency or linked file it will take you to that file. It was great.

PhpStorm is kind of slow, I found that Prettier was taking a long time to format my code, and it just was lagging a lot so I was looking for alternatives. After watching some more tutorial videos I noticed that everyone was using Visual Studio Code. So I gave it a go, and its amazing.

It has support for everything I need with the plugins and the integration with Git is amazing. The speed of this IDE is blazing fast, and I wouldn't go back to using PhpStorm anymore. I highly recommend giving Visual Studio Code a try!

13 upvotes·18.8K views

Decision at Airbnb about Apollo, GraphQL, Visual Studio Code, Git, GraphQLSchema

Avatar of adamrneary
Engineer at Airbnb ·
ApolloApollo
GraphQLGraphQL
Visual Studio CodeVisual Studio Code
GitGit
#GraphQLSchema

One of the joys I wanted to demonstrate in a GraphQL Summit talk I did is having so many helpful tools at my fingertips while building our product at Airbnb. This includes access to Git in Visual Studio Code, as well as the integrated terminal and tasks for running frequently-needed commands.

Of course, we also had some fun stuff to show for GraphQL and Apollo! The part that most people had not seen was the new Apollo GraphQL VS Code Extension. There is no need for me to copy over all juicy features from their marketing site (there are many!), but I will elaborate on one feature: Schema Tags.

If you are going to lint your queries against the schema you are working on, you will invariably be presented with the decision of “which schema?” The default may be your production schema (“current,” by convention), but as we discuss in the demo, if you need to iterate and explore new ideas, you need the flexibility of targeting a provisional schema.

Since we are using Apollo Engine, publishing multiple schemas using tags allows us this flexibility, and multiple engineers can collaborate on a single proposed schema. Once proposed schema changes for a service are merged upstream and those changes are naturally flowing down in the current production schema, we can flip back to “current” in VS Code. Very cool.

#GraphQLSchema

11 upvotes·10.7K views

Decision about Amazon EC2, LXC, CircleCI, Docker, Git, Vault, Apache Maven, Slack, Jenkins, TeamCity, Logstash, Kibana, Elasticsearch, Ansible, VirtualBox, Vagrant

Avatar of Puciek
Devops guy at X20X Development LTD ·
Amazon EC2Amazon EC2
LXCLXC
CircleCICircleCI
DockerDocker
GitGit
VaultVault
Apache MavenApache Maven
SlackSlack
JenkinsJenkins
TeamCityTeamCity
LogstashLogstash
KibanaKibana
ElasticsearchElasticsearch
AnsibleAnsible
VirtualBoxVirtualBox
VagrantVagrant

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.

10 upvotes·2 comments·20.6K views

Decision about Git, Heroku, Rails, PersonalStack, ProjectGenerator, Productivity

Avatar of jeromedalbert
Senior Backend Engineer at StackShare ·
GitGit
HerokuHeroku
RailsRails
#PersonalStack
#ProjectGenerator
#Productivity

Rails is great because "all the decisions are made for you", right? But I wouldn't be writing this decision if this were truly the case. ;-)

rails new and boilerplate generators are nice, but you still have to spend some time adding your favorite gems, tools, formatting files to your standards, removing unused functionality, and configuring deploys. Only after all of this can you truly begin to code.

That’s why I made a shell script (yeah, Rails generators are overkill) that creates a new app from a boilerplate app I preconfigured. Everyone has different tastes and levels of seniority, so I am not sharing this app to the public. Just know that it has different Git branches that my shell script can choose: master (default config), devise, forms, worker, etc. It comes bundled with the tools listed in my personal stack.

All I have to do is run the script, follow the README, and 2 minutes later my app is running a hello world page on Heroku! I cannot stress how powerful it is to have a professional-grade application ready and deployed in 2 minutes. It feels like I’m cheating the system. These superpowers have proved invaluable for personal projects, hackathons and professional projects alike.

Productivity ProjectGenerator PersonalStack

9 upvotes·1 comment·7.8K views

Decision at Zulip about Mercurial, Git

Avatar of tabbott
Founder at Zulip ·
MercurialMercurial
GitGit

I've been excited about Git ever since it got a built-in UI. It's the perfect combination of a really solid, simple data model, which allows an experienced user to predict precisely what a Git subcommand will do, often without needing to read the documentation (see the slides linked from the attached article for details). Most important to me as the lead developer of a large open source project (Zulip) is that it makes it possible to build a really clean, clear development history that I regularly use to understand details of our code history that are critical to making correct changes.

And it performs really, really well. In 2014, I managed Dropbox's migration from Mercurial to Git. And just switching tools made just about every common operation (git status, git log, git commit etc.) 2-10x faster than with Mercurial. It makes sense if you think about it, since Git was designed to perform well with Linux, one of the largest open source projects out there, but it was still a huge productivity increase that we got basically for free.

If you're learning Git, I highly recommend reading the other sections of Zulip's Git Guide; we get a lot of positive feedback from developers on it being a useful resource even for their projects unrelated to Zulip.

6 upvotes·6.9K views

Decision at SmartZip about Git, Gemfury, Rails, Ruby, Gemfury, Rubygems

Avatar of juliendefrance
Principal Software Engineer at Stessa ·
GitGit
GemfuryGemfury
RailsRails
RubyRuby
#Gemfury
#Rubygems

Working with Ruby on Rails also means working with #RubyGems Most of the time, the community has some gems you can use and list down your #Gemfile. But sometimes, you also need to come up with your own proprietary ones to encapsulate and re-use some of your business logic.

It is critical that such repositories and their source code remain private, secure. Even though your code shouldn't contain any credentials, this still applies to your gems' distribution channels. Unless for parts you've willingly open sourced, you don't want your intellectual property stolen.

Rubygems.org therefore, not being an option for this use case, I faced two alternatives: accepting the overhead of maintaining my own gem server, or finding a service that does it for me.

Obviously, the latter was the way to go:

I chose Gemfury for its convenience, pricing model, and reliability.

Gemfury also allowed me/my team to publish gems via different methods: file upload, SSH, HTTPS, or as simple as a Git push.

6 upvotes·3 comments·2.6K views

Decision at Typeform about Docker Compose, Docker, Git, Vim, Visual Studio Code, Go

Avatar of Denys
Software engineer at Typeform ·
Docker ComposeDocker Compose
DockerDocker
GitGit
VimVim
Visual Studio CodeVisual Studio Code
GoGo
  • Go because it's easy and simple, facilitates collaboration , and also it's fast, scalable, powerful.
  • Visual Studio Code because it has one of the most sophisticated Go language support plugins.
  • Vim because it's Vim
  • Git because it's Git
  • Docker and Docker Compose because it's quick and easy to have reproducible builds/tests with them
  • @Archlinux (wtf it's not here?!) because Docker for Mac/Win is a disaster for the human's central nervous system, and Arch is the coolest Linux distro so far
5 upvotes·15.1K views

Decision about GitLab, Git, WebStorm, Amazon DynamoDB, AWS CloudFormation, AWS Lambda, Go, Bootstrap, redux-saga, Redux.js, React, JetBrains, Serverless

Avatar of devalias
Hack. Dev. Transcend. ·
GitLabGitLab
GitGit
WebStormWebStorm
Amazon DynamoDBAmazon DynamoDB
AWS CloudFormationAWS CloudFormation
AWS LambdaAWS Lambda
GoGo
BootstrapBootstrap
redux-sagaredux-saga
Redux.jsRedux.js
ReactReact
#JetBrains
#Serverless

Working on a project recently, wanted an easy modern frontend to work with, decoupled from our backend. To get things going quickly, decided to go with React, Redux.js, redux-saga, Bootstrap.

On the backend side, Go is a personal favourite, and wanted to minimize server overheads so went with a #serverless architecture leveraging AWS Lambda, AWS CloudFormation, Amazon DynamoDB, etc.

For IDE/tooling I tend to stick to the #JetBrains tools: WebStorm / Goland.

Obviously using Git, with GitLab private repo's for managing code/issues/etc.

5 upvotes·1 comment·5.4K views

Decision about Git, Prettier, Visual Studio Code, Protobuf, GitLens, TSLint

Avatar of omidfarhang
Sr. Full Stack Developer ·
GitGit
PrettierPrettier
Visual Studio CodeVisual Studio Code
#Protobuf
#GitLens
#TSLint

My Favorite #IDE is Visual Studio Code bundled with Prettier and #TSLint and #GitLens for better Git management, Bracket Pair Colorizer 2 has been also a big help over time. Also #Protobuf support has been a big help in our recent project. And the most addictive shortcut has been Ctrl + Shift + I to organize imports

5 upvotes·1.8K views

Decision about Visual Studio Code, GitHub, Git, Cloud Firestore, Dialogflow, Google Compute Engine, Vue.js, FeathersJS, Node.js, Firebase

Avatar of fontumi
Visual Studio CodeVisual Studio Code
GitHubGitHub
GitGit
Cloud FirestoreCloud Firestore
DialogflowDialogflow
Google Compute EngineGoogle Compute Engine
Vue.jsVue.js
FeathersJSFeathersJS
Node.jsNode.js
FirebaseFirebase

Fontumi focuses on the development of telecommunications solutions. We have opted for technologies that allow agile development and great scalability.

Firebase and Node.js + FeathersJS are technologies that we have used on the server side. Vue.js is our main framework for clients.

Our latest products launched have been focused on the integration of AI systems for enriched conversations. Google Compute Engine , along with Dialogflow and Cloud Firestore have been important tools for this work.

Git + GitHub + Visual Studio Code is a killer stack.

4 upvotes·1.9K views