What is Reddit's opinion of Travis CI?

From 3.5 billion Reddit comments

On most architectures, yes. Clang 9.0.0 introduced support for asm goto which enabled compiling the kernel on x86_64 archs. Many other architechtures were buildable even before that.

jrnl did this before: https://github.com/jrnl-org/jrnl/issues/883#issuecomment-606954377

I tried to explain why it's actively stupid to pin pytz versions, but was completely ignored (they are still pinned): https://github.com/jrnl-org/jrnl/issues/783#issuecomment-624274011

Now, they refuse to update cryptography out of some fear that it's "incompatible with Windows", but the actual problem that resulted in their CI failing was https://travis-ci.com/github/jrnl-org/jrnl/jobs/366385220#L133-L140

tl;dr One of the other dependencies, cffi==1.14.1, failed to install because pip got permission denied errors trying to write to %userprofile%\AppData\Local\Temp. How that could possibly be an indictment on "cryptography" I do not know.

It's pretty obvious that jrnl is just aggressively unfriendly to Linux distros. The correct solution is to apply a PKGBUILD patch that removes all version pinning from the pyproject.toml, and in the highly unlikely case actual issues are encountered, report a bug.

So much ado about nothing, merely because the AUR maintainer isn't responsible enough to say no to a crazy upstream.

Apologies, but none of your components appear to have tests nor an integration with, for example, Travis CI.

These are the first things you need if you hope for adoption by others.

Otherwise, a “kickass web application” built on top of these components quickly turns into a potential kick in the groin.

This is a Travis configuration that automatically pulls and installs the SBCL version configured in the environment variable on three different OSes. I post it here in case someone else wants to tackle a similar problem in the future.

Currently SBCL is compiled from source each time the CI runs. A possible improvement is to have Travis build SBCL once and cache it in GitHub releases of some repository; I'll do that soon and post the results here.

Example run: https://travis-ci.com/phoe-trash/furcadia-post-splitter/builds/133614805

Automated testing. That means using an off-the-shelf CI like travis or the one that it built in to gitlab or often something on-site.

If I join a project and it doesn't have automated testing or even worse, has shitty tests, that's typically the first thing that I force upon people and generally it improves things a lot.

You mean travis-ci.com? They give you 1000 minutes that don't renew but you can apply to be part of their open source allotment. But as you can see the article, they have stated adding projects to that open source allotment is on hold right now.

You're missing a great deal from your .travis.yml as well as some information about the project.

First, what script do you run in package.json to do tests? If it's just "test": "jest" then the setup should be simple. Something like

language: node_js
node_js: 14

jobs:
  include:
    - stage: "Run Jest tests"
      script: yarn test

Example build from travis

Repo it was run from repo

Docs for setting up Jest with Gatsby.

Thanks for all the help! I achieved what I was looking for!

What I ended up doing was switching over from Jenkins to Travis CI (best decision ever). Reason why I hesitated was because I didn't know how to use it, but after an hour of reading the documentations and researching. It was easy to configure the travis.yml and got my build to successfully run. I learned another CI/CD tool. They even had support for Django - wonderful.

https://travis-ci.com/github/WillWcchan/Visual-Option-Chain-Graph

For AWS EC2, I don't need it anymore since Travis CI can take over the responsibilities. I'll stick with maybe using AWS EC2 / AWS ElasticBeanStalk to host my final application at the end of the DevOp cycle (I'm still in the early beginning of testing).

A CI stands for Continuous Integration which means that as soon as you push or merge something (depends on your config) to, for example, the master branch, a script/process will run automatically.

Such a script can, for example, consist of first building the application and then running unit tests. And if all goes well, it will be deployed to the server. That is a short explanation about a CI.

GitHub has its own CI called GitHub Actions. But you also have other CI services such as Travis CI.

I'm trying out Github Actions, and I just published this Action which other Elisp developers might like to use. It's built on top of my recently-published nix-emacs-ci project. Would love to have some feedback from any early users. :-)

Author here. Happy to help with this, but don't know anything about arch. Would a starting point be a aarch64-unknown-linux-gnu build? (Mine is broken currently on travisCI).

Wow! Way to resort to troll tactics.

1) I don't have multiple accounts.

2) I'll talk about anything that I feel like talking about. Including about companies even though I don't use their services.

3) Travis CI is a paid service unless your project is completely open source. OP's App is unlikely to qualify for this free option. Cheapest Travis CI plan is $69 USD per month.

4) OP is an individual that doesn't have that kind of money. So Travis CI even with **free** fastlane is NOT an option for him.

5) I did give the OP actually useful info. Unlike you.

6) I have better things to do than to argue with a troll like you all day.

Yeah you should ideally ignore your compiled source locally. You can create a file named .gitignore in the repository and add the patterns of folders to ignore. It will then not be tracked. As a rule committing compiled source leads to nothing but problems with conflicts which can’t be resolved so when multiple people committing some will lose their changes from compiled source. I’m mostly from .net world but have used team city and Jenkins and Octopus deploy to do this ( these are continuous integration tools). You can do this for free with github using travis (https://travis-ci.com/ ) so it will run commands like gulp npm grunt yarn etc to sort all your packages for your js and css.

> I'm looking at starting a new project and I'd like to bring some friends on board to help out, so I want to make sure I have a good development setup. Mainly I'm curious about how to setup the project so that developers can deploy their changes locally and iterate before putting up a pull request.

Uhh... just put your project on github/gitlabs and let them do git clone? You can possibly set up a Docker image too so others don't have to install all dependencies manually just to run your app.

> Also if anyone has any web-app deployment tips beyond just having the server pull down the latest version of the code regularly, please let me know.

I would take example from how others do it, like Discourse for example. Code itself is written in Ruby on Rails but many features from that you will want in your own application:

• Automated building procedure (in this case via Travis). Someone makes a pull request and it's tested if whole thing still works afterwards automatically.
• Stable and unstable/testing branches. You probably don't want your production code to actually switch to latest version everytime. Make one working version and an extra branch with additional features, only once they are polished and well tested you merge them (stable branch only gets critical security fixes in the meantime). If someone really wants they can use unstable version.

I am a software developer, and I work on huge mega-projects with dozens+ developers at a large, well-known corporation.

We basically don't ever use the term 'regression test' internally, because we run all our tests (unit tests, larger functional tests, integration tests) at every change list, so by definition our unit tests are also regression tests. This isn't just us - open source continuous integration platforms like Travis-CI follow this exact philosophy as well.

There's no point to using the term 'regression test' in such an environment -- every test is by definition a regression test, so we just distinguish based on the actual size and complexity of the test itself (e.g. does the test talk to a production environment, does the test run only in-memory, does it load multiple services).

I think your suggestion that GP educate himself on QA is not really appropriate. You're being quite presumptuous in assuming that anyone whose use of terms doesn't match yours must not know what they're talking about, especially in a field like software engineering, where the terms and concepts are relatively loose and can change very quickly, and where companies use words in slightly different ways.