What does genius look like in math? Where does it come? Dandelin spheres [video] - <AUTHOR> https://www.youtube.com/watch?v=pQa_tWZmlGs <comment><USER2> 3Blue1Brown is amazing -- one of the best math explainers I have seen. He also had a good video on other math channels he likes ([https://www.youtube.com/watch?v=VcgJro0sTiM](https://www.youtube.com/watch?v=VcgJro0sTiM)). It's amazing to see how things have changed over the last couple of years. Earlier, searching for math explanations on YT, I felt like I mostly saw hard- to-follow lectures. Now there's tons of content created specifically for YT and it is really well done.

</comment><comment><USER3> 3Blue1Brown saved me when I started university comp sci math 10 years after highschool. One of my favorite youtube channels. His Fourier Transform videos are the best explanations I've seen.

</comment><comment><USER4> Sidenote: 3Brown1Blue has the most intuitive explanations for linear algebra and matrix operations I have found thus far. Check his playlists series.

</comment><comment><USER5> I don't watch YouTube much but I have see a few of these videos. This one was recommended to me last night and I watched it. Now it's here on HN the next morning. This is certainly not a coincidence.

Favorite quote "You can often view glimpses of ingeniousness... not as inexplicable miracles, but as the residue of experience." Did he pen that one or borrow it from someone else?

<comment><USER6> Google doesn't recognise "residue of experience" as part of a familiar quote, but the phrase itself seems to be rather frequent, at least in academese: [https://www.google.com/search?q=%22residue+of+experience%22](https://www.google.com/search?q=%22residue+of+experience%22).

<comment><USER7> Funnily enough, as of this writing, the top ranked google result (at least for me) is this post.

<comment><USER8> I'm so meta even this acronym

<comment><USER9> While Redditisms leaking into HN comments are usually downvoted, I actually _got_ this for the first time just now. Probably because while on HN I wear my thinking cap, and on Reddit I read mainly for amusement and don't spend the time to look as closely. So a qualified thank you, that was clever.

<comment><USER10> It was popularized by Douglas Hofstadter, the guy who wrote _Gödel, Escher, Bach_ among other things. [https://en.wikipedia.org/wiki/Douglas_Hofstadter](https://en.wikipedia.org/wiki/Douglas_Hofstadter)

</comment></comment></comment></comment></comment></comment><comment><USER11> 'Reside of experience'. Yes, more especially the residue of _imaginative experience_.

Daydreaming can be dysfunctional & defensive, as in:

[https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5962718/](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5962718/)

Yet some people are free in their thoughts at least some of the time and thus are able to daydream productively.

(One difference I think is that they are obsessed with _problems_ ).</comment>


8-bit number to binary string - <AUTHOR> http://gynvael.coldwind.pl/n/c_cpp_number_to_binary_string_01011010 <comment><USER2> The big constants used in the formula

        void to_bin(unsigned char c, char *out) {
          *(unsigned long long*)out = 3472328296227680304ULL +
            (((c * 9241421688590303745ULL) / 128) & 72340172838076673ULL);
        }

are much more obvious when they remain in hex:

0x3030303030303030 -- the byte array of '0's encoded as ASCII

0x8040201008040201 -- the magic

0x101010101010101 -- only 0 or 1 to be added to the appropriate array element

Therefore, more readable:

        void to_bin(unsigned char c, char *out) {
          /* endian dependent, works on x86 */
          *(unsigned long long*)out = 0x3030303030303030ULL +
            (((c * 0x8040201008040201ULL) >> 7) & 0x0101010101010101ULL);
        }

The function is of course endian dependent (I'd add a comment about that fact in it) and the explanation of the quoted function on the page starts at "If you shift the the constant by 7 bits to the right." The page is a result of an edit where the older function (that ends with + c / 128;) was explained first.

Still, nice.

<comment><USER3> Towards the bottom of the article it says:

 _the last thing I did was changing the constants to decimal - they look way more scary this way ; >_

because, you know, programming should be innately difficult and confusing so we can laugh at others who understand less than we do.

Never underestimate how many times code (any code) posted online will be copy/pasted throughout the world everywhere from school projects to production systems.

<comment><USER4> The whole thing is whimsy. You'd never want to use this approach at all in a production system. Using decimal constants instead of hex is the least of the sins here.

There should be room in programming for whimsy. This stuff is fun, and play is healthy. If somebody takes this thing seriously and copies the code into a production system, that's their own fault, not the author's.

<comment><USER3> My job is basically fixing the code and processes of corporate programmers who copy/paste examples from websites into production systems. There's little understanding of how the code works and almost no reading of related documentation. _If I compiles, I ships._

It's like if bridge designers didn't really know mechanics and just copy/pasted minecraft designs into the real world. Sure, it's not the fault of minecraft designers, but we can help kill fewer people by making better examples.

<comment><USER4> I don't think that analogy really works. If bridge designers were doing this, there would be massive outcry and we'd put a stop to it. We allow it to happen with (terrible) programmers only because the harm they do is pretty limited, and nobody's getting killed because of it.

<comment><USER3> _there would be massive outcry and we 'd put a stop to it._

Massive security branches? Massive fraud? Ineffective nationalized cybercommands?

Just because we can't see the world burning with our eyes doesn't mean lead in the air isn't giving us brain damage.

<comment><USER4> These are all because of people copy/pasting code from the internet?

</comment></comment></comment></comment></comment></comment></comment><comment><USER5> Awesome. I'm always amazed by bitmagic like this. Today I saw one on stackoverflow and spent a good deal of time failing to understand it:

[https://stackoverflow.com/questions/33532045/how-to-swap- fir...](https://stackoverflow.com/questions/33532045/how-to-swap- first-2-consecutive-different-bits)

And of course I'm reminded of the fast inverse square root:

[https://en.wikipedia.org/wiki/Fast_inverse_square_root](https://en.wikipedia.org/wiki/Fast_inverse_square_root)

</comment><comment><USER6> Why isn't this faster than the "standard" loop based version? The disclaimer at the start says it's not, but I would have thought that 4 64bit math operations would be much faster than a loop with 8 steps and comparisons and so on.

<comment><USER7> First and foremost: YES, I KNOW! This is completely senseless microbenchmarking and micro-optimization. I ONLY LOOK AT THIS FOR FUN.

That being said. The 64bit multiplication is faster, and also constant in time. I've measured this using the timestamp counter which doesn't necessarily count actual CPU clock cycles, but possibly an integer multiple of it (seems to output always numbers divisable by 8 for me).

        (...)
        100 loop:01100100(152) 64bit:01100100(48)
        101 loop:01100101(128) 64bit:01100101(48)
        102 loop:01100110(160) 64bit:01100110(48)
        103 loop:01100111(128) 64bit:01100111(48)
        104 loop:01101000(192) 64bit:01101000(48)
        105 loop:01101001(88) 64bit:01101001(48)
        106 loop:01101010(152) 64bit:01101010(48)
        107 loop:01101011(128) 64bit:01101011(48)
        108 loop:01101100(160) 64bit:01101100(48)
        (...)

That's on an _Intel(R) Core(TM) i5 CPU M 450 @ 2.40GHz_ and the cycles include the rdtsc, a few movs, and the call to the respective function.

[https://github.com/vogelchr/bitstring_via_64bit_mult](https://github.com/vogelchr/bitstring_via_64bit_mult)

<comment><USER8> I couldn't resist so I tried a table look-up (16 elements) version which was about twice as fast as the multiply version.

Intel Core i5-3210M @ 2.50GHz

<comment><USER9> Funny, I read about the first part of the sentence 'I tried a table look-up' and thought immediately WHAT ABOUT THE CACHE?

Then I continued '16 elements', oh, OK then, next time I'll try to read the whole sentence first.

</comment></comment></comment></comment><comment><USER10> Rather than add 0x3030303030303030, you could OR with it because you know there will never be a carry. This may save cycles on some architectures.

</comment><comment><USER11> This is an example of SIMD Within A Register. There are some more neat examples here: [http://aggregate.org/MAGIC/](http://aggregate.org/MAGIC/)

</comment><comment><USER3> Here's a fancier, slightly less-magic, version. How to compile is left as an exercise for the reader (hint: Haswell or newer, requires BMI2 instruction set):

        void toBinary(uint8_t byte) {
            uint64_t zeroes = *(uint64_t *)"00000000";
            uint64_t resultStr =
                zeroes | __builtin_bswap64(_pdep_u64(byte, 0x0101010101010101ULL));

            printf("hello: %.*s\n", 8, (char *)&resultStr);
        }

<comment><USER12> This really reminds me of the old demoscene diskmag Hugi article about adding 16 bit colors (without MMX).

[http://www.hugi.scene.org/online/hugi18/cobrad.htm](http://www.hugi.scene.org/online/hugi18/cobrad.htm)

</comment></comment><comment><USER13> For Python

        >>> f1=lambda c: __import__('struct').pack('<Q', 3472328296227680304  + (((c * 9241421688590303745) / 128) & 72340172838076673))
        >>> f1(1)
        '00000001'
        >>> f1(2)
        '00000010'
        >>> f1(5)
        '00000101'
        >>> f2=lambda c: struct.pack('<Q', (((c * 0x8040201008040201) / 128) & 0x0101010101010101))
        >>> f2(1)
        '\x00\x00\x00\x00\x00\x00\x00\x01'
        >>> f2(2)
        '\x00\x00\x00\x00\x00\x00\x01\x00'
        >>> f2(101)
        '\x00\x01\x01\x00\x00\x01\x00\x01'

Use "<" for little-endian for x86

</comment><comment><USER14> > x86 is little endian - that's why it's backwards

This can be read the wrong way, although it is correct: the author is referring to the final byte sequence and not the input bit sequence. Endianness applies to bytes, not bits.

</comment><comment><USER15> Nice little problem. Thanks for sharing!

</comment><comment><USER16> Cool but I want to say I've seen similar, google turns up: [http://www.asmcommunity.net/forums/topic/?id=28498](http://www.asmcommunity.net/forums/topic/?id=28498)

</comment><comment><USER17> I recommend reading over this: [http://0x80.pl/articles/convert-to- bin.html](http://0x80.pl/articles/convert-to-bin.html)

btw all this SWAR stuff should be aligned before applying.

</comment><comment><USER18> Be careful with alignment. On architectures where it matters, the caller may pass in a "char* out" which is not suitably aligned, and doing an "unsigned long long" store into that address may fault.

</comment><comment><USER19> Feature request: add a parameter that specifies the base into which the function rewrites the number.</comment>


Alice's adventures in algebra (2009) - <AUTHOR> https://www.newscientist.com/article/mg20427391-600-alices-adventures-in-algebra-wonderland-solved/ <comment><USER2> I got 1/3 through this article and the silliness made me stop. There was absolutely nothing controversial about imaginary and complex numbers in the Victorian era. The unprovability of Euclid's parallel postulate had a tremendous impact on mathematics and logic; Euclid was no longer regarded as a perfect model. The author's understanding of the etymology of algebra is absurd. The 'restoration and reduction' it refers to is setting a broken bone --moving back and forth from one side of the equation to the other like a doctor setting a bone--and not shrinking in size as the author seems to think. With so many untrue premises I have no interest in the author's conclusion.</comment>


Visa warns of POS malware incidents at gas pumps across North America - <AUTHOR> https://www.zdnet.com/article/visa-warns-of-pos-malware-incidents-at-gas-pumps-across-north-america/ <comment><USER2> Neither the article nor the malware reports it links to identify which merchant networks are affected.

<comment><USER3> I'm not sure it actually matters with the prevalence of skimmers plus this and even cameras taking pictures of cards.

I've had 3 compromised cards just this year, so now I just go inside and pay.</comment></comment>


Ask HN: How to create and remember strong passwords - <AUTHOR> For a long time on I have been trying to create strong passwords in order to have a greater account security. I used to create random strings and use them one per page however each time its becoming more difficult to keep them changed frequently. I have given up to create a different password on every site and I have relied on lastpass for pages I don't really care about. In opposite, here are many places where I want to have true secure passwords. AWS, GitHub, corporate account, etc. However, with so many accounts I always end up pressing the "Forgot your password?" and start again. I have tried Diceware but didn't end up well. What is the tool you have sticked with to create secure and memorable passwords? <comment><USER2> > to create secure and memorable passwords?

Step 1: Stop worrying about "memorable" passwords and focus _only_ on secure. Anyone today with even a tiny internet presence will have a larger number of passwords than can be memorized by that person (without many of them being reused).

Step 2: Pick a password manager (preferably one with a built in "generate random password" feature). Which manager is less important than looking for specific features that you will need/want to make use of the manager. But the "generate random password" feature should be tops in your list. All managers /should/ have this feature, but if by chance you find one that does not, remove it from your selection list.

Step 3: After you select a manager, then always use the "generate random password" feature for generating secure, unique, passwords for all websites you visit that need passwords. Note the word 'all' above, it is important. Once you go this route, you should never reuse the same password anywhere, and you should never 'make up' a password manually, no matter how throwaway you consider an account. Always use the password manager to generate a secure password. If you later decide to throw the account away, you can delete the password entry from your manager. But if the account becomes non-throwaway later, which does happen, you will already be using a secure unique password.</comment>


Ask HN: How was this design technique achieved? - <AUTHOR>

I saw this article on ESPN and I was very impressed with the technique that was used. Basically there is a long scrolling single page and in between the "chapters" there is a background image that stays in place while the paragraph scroll along it until its covered.
Here is the url: http://espn.go.com/espn/feature/story/_/id/11717596/is-kobe-bryant-reason-los-angeles-lakers-downfall
Follow up - What is the best way to learn a design technique seen in the wild? <comment><USER2> Searching for "parallax scrolling" should get you were you need to go. Here's a jquery plugin you can use, one of many:

[http://ianlunn.co.uk/plugins/jquery- parallax/](http://ianlunn.co.uk/plugins/jquery-parallax/)</comment>


Why I'm Switching from React to Cycle.js - <AUTHOR> https://www.sitepoint.com/switching-from-react-to-cycle-js/ <comment><USER2> Wonder if the author tried MobX before settling on Cycle.js... It was not mentioned once</comment>


GitHub Actions now supports CI/CD, free for public repositories - <AUTHOR> https://github.blog/2019-08-08-github-actions-now-supports-ci-cd/ <comment><USER2> This is very interesting to me. It also makes me think about the natural rise of monopolies and monoculture in tech. GitHub has really been extending to "eating the world" as of late. Recently in terms of their package registry that must have folks like Artifactory and Nexus a bit shaken, and now this, which is bad news for folks like CircleCI (and I say this as a CircleCI user).

As a developer, in the short term I love this. Fewer things I need to cobble together and worry about how to integrate. I mean, it's already the case that if GitHub goes down that my CircleCI jobs won't work, so having one company to yell at and monitor alone is a plus.

But long term it makes the competitive ecosystem much less robust. And as a startup employee, makes me feel how disrupting established platform competitors gets that much more difficult - even if you have a better product, it's hard to fight against the "platform" as they have more integrated points of value.

<comment><USER3> A monopoly is not inherently bad. They often benefit users with increased efficiency and productivity. They're only bad when progress stagnates and/or prices rise.

In this case, Github is actively competing and adding features that helps all of their users. If that means that some other companies lose market share then it's just a sign that the value proposition has changed. I see no problem with this, it's how the market works.

<comment><USER4> In what real scenario do you see a monopoly not doing exactly what monopolies do? Do they have some moral code they can't break? Do they hate money? What exactly is it that would make them immune to human tendencies?

<comment><USER5> Monopolies are subject to the laws of economics.

GitHub has gained near-monopoly status because it has provided a superior user experience at a great price. If either of those value propositions start to crumble,

      git remote add ...

Exploitative monopolies almost always have help from the state: The Patent Office, Interstate Commerce Commission, Federal Reserve, FDA, etc either grant monopoly or cartel privilege to their customers. Monopolies achieved on the market cannot be sustained without continuing to satisfy customer demands.

<comment><USER6> The point I think is that as GitHub adds more and more integrations (git + issues + fork graph + CI/CI + ...) then it's not so simple to move to another service. The vertical is more convenient until you realize you're an Oracle customer all over again.

<comment><USER7> With CI, I wonder if someone could build a tool which had some sort of DSL to define your CI pipeline, and then translated that to configuration files for multiple CI providers (Travis CI, CircleCI, GitHub Actions, Jenkins, etc.) If you write all your CI pipelines in that DSL, then moving to another provider would be just telling the tool to generate output for another backend.

(One issue is that such a DSL could only provide lowest common denominator functionality... or else, suppose CI providers 1 and 2 offer feature X but 3 and 4 don't, then if you use feature X, you can switch between 1 and 2, but the tool would give an "unsupported feature" error if you tried to generate output for 3 or 4.)

<comment><USER8> Having migrated from Travis to CircleCI for most of my active projects, I'd say their models are so vastly different it's pretty much impossible to have an AST of sort that can be translated to both except for the simplest and most well-encapsulated cases (at least not before Travis supposedly improved Docker support, by which point I was already gone).

</comment></comment></comment></comment></comment></comment></comment><comment><USER9> This is great news for developers. The trend has been to combine version control and CI for years now. For a timeline see [https://about.gitlab.com/2019/08/08/built-in-ci-cd- version-c...](https://about.gitlab.com/2019/08/08/built-in-ci-cd-version- control-secret/)

This is bad news for the CI providers that depend on GitHub, in particular CircleCI. Luckily for them (or maybe they saw this coming) they recently raised a series D [https://circleci.com/blog/we-raised-a-56m-series-d-what-s- ne...](https://circleci.com/blog/we-raised-a-56m-series-d-what-s-next-for- circleci-customers/) and are already looking to add support for more platforms. It is hard to depend on a marketplace when it starts competing with you, from planning (Waffle.io), to dependency scanning (Gemnasium acquired by us), to CI (Travis CI layoff where especially sad).

It is interesting that a lot of the things GitHub is shipping is already part of Azure DevOps [https://docs.microsoft.com/en- us/azure/architecture/example-...](https://docs.microsoft.com/en- us/azure/architecture/example-scenario/apps/devops-dotnet-webapp) The overlap between Azure DevOps and GitHub seems to increase instead of to be reduced. I wonder what the integration story is and what will happen to Azure DevOps.

<comment><USER10> It's a horrible trend. CI should not be tied to version control. I mean we all have to deal with it now, but I'd much rather have my CI agnostic and not have config files for it checked into the repo.

I've browsed through the article you linked to, one of the subtitles was "Realizing the future of DevOps is a single application". Also a horrible idea: I think it locks developers into a certain workflow which is hard to escape. You have an issue with your setup you can't figure out - happened to me with Gitlab CI - sorry, you're out of luck. Every application is different, DevOps processes is something to be carefully crafted for each particular case with many considerations: large/small company, platform, development cycle, people preferred workflow etc. What I like to do is to have small well tested parts constitute my devops. It's a bad idea to adopt something just because everyone is doing this.

To sum it up, code should be separate from testing, deployment etc. On our team, I make sure developers don't have to think about devops. They know how to deploy and test and they know the workflow and commands. But that's about it.

<comment><USER11> I'm an operations guy, but I think I have a different perspective. The developers I work with don't have to think about CI/CD, but the configuration still lives in the repo, I'm just a contributer to that repo like they are.

Having CI configuration separate from the code sounds like a nightmare when a code change requires CI configurations to be updated. A new version of code requires a new dependency for instance, there needs to be a way to tie the CI configuration change with a commit that introduced that dependency. That comes automatically when they're in the same repo.

<comment><USER12> Having CI configuration inside the codebase also sounds like a nightmare when changes to the CI or deployment environment require configuration changes or when multiple CI/deployment environments exist.

For example as a use case: Software has dozens of tagged releases; organization moves from deploying on AWS to deploying in a Kubernetes cluster (requiring at least one change to the deployment configuration). Now, to deploy any of the old tagged releases, every release now has to be updated with the new configuration. This gets messy because there are two different orthogonal sets of versions involved. First, the code being developed has versions and second, the environments for testing, integration, and deployment also change over time and have versions to be controlled.

Even more broadly, consider multiple organizations using the same software package. They will each almost certainly have their own CI infrastructure, so there is no one "CI configuration" that could ever be checked into the repository along with the code without each user having to maintain their own forks/patchsets of the repo with all the pain that entails.

<comment><USER13> > organization moves from deploying on AWS to deploying in a Kubernetes > cluster

I had (and still have) high hopes for circleci's orbs to help with this use case. Unfortunately, orbs are private - which makes it a no-go for us.

But, in my dream world, we have bits of the deployed configuration that can be imported from else where - and this is built right into the CI system.

In practice, for my org, the code and configuration for the CI comes from both the "infra" repo as well as the "application" repo. The configuration itself is stored in the app repo, but then there's a call `python deploy_to_kubernetes.py <args>`. The `deploy_to_xxx.py` script would be in the "infra" repo.

It also depends on your workflow - do you change the common deploy infrastructure more often, or do you change the application specific deploy infra more often.

Yeah, writing code to deploy code is sometimes fun, but sometimes nasty.

</comment></comment></comment></comment></comment><comment><USER14> Just a warning for those who haven't ventured into actions yet, I would have to say so far I've found the experience very, very average. Even just doing something simple like posting a release notification to Slack seems to end up with me having the action triggered a random number of times causing multiple messages being posted to slack. The whole experience feels amateur and clunky.

There are issues open to look into it but no fix in sight yet. While this announcement sounds useful, don't throw away your current CI/CD tooling which is probably a lot nicer to use.

Lastly I really dislike how pretty much any really useful actions are created and maintained by single people. There are just some actions I'd want to see be supported by GitHub, I don't wan to have to handover things like Slack access keys to a non-trusted third party to post messages.

Every time I try to use actions I'm surprised it was launched in it's current obscure, unpolished state.

<comment><USER15> This feature release has been a dumpster fire from my perspective. I love GitHub and what they are trying to do, but I read over the Actions documentation 2x and I still can't tell if my use case is supported: I just want to see if master builds on a net core app without spinning up or otherwise utilizing some other cloud instance.

Also, I am not even sure what the appropriate syntax to use is with all the mixed messaging and examples (YAML or the other thing? Which do I use!?).

Regardless of which variant of syntax I attempted, the actions UI told me there was some generic error and that nothing was to be done. One additional problem I noticed is that if you have a protected master branch, you are going to be forced to get code reviews from your team every single time you try to iterate on the workflow script. There is no apparent way to test or validate actions without committing directly to master and seeing what the result may be.

All around, a complete mess in my estimation. I will be sticking with Jenkins for the foreseeable future. This GH feature is apparently not designed for people who care about straightforward solutions to simple problems:

      git clone <repo>
      dotnet build
      <if failure, flag build, create issue, send email, etc>

That is all I want to do, Microsoft. Can you handle that? I feel like there should just be a simple toggle switch in my GH repo for this concern, considering Microsoft is now responsible for that entire vertical stack.

</comment></comment><comment><USER16> As a Gitlab user that's not strongly committed to the platform, this looks like a pretty interesting option.

Anyone have thoughts on how this compares to e.g. Google Cloud Builder in terms of functionality? Being integrated into the GH backend seems like a big perk, rather than having to use webhooks for everything.

Seems like you can do things like build your Docker containers ([https://developer.github.com/actions/creating-github- actions...](https://developer.github.com/actions/creating-github- actions/creating-a-docker-container/)).

One thing that's great about Gitlab is the Gitlab server/runner split, where you can run workers in your own VPC, but still use their hosted offering. This makes it easier to keep your deploy secrets (aka the keys to the kingdom) locked down, as they never leave your cloud provider.

<comment><USER17> > Google Cloud Builder

It's actually Cloud Build under the covers. Their Actions Library sure beats have to figure out how to write the configs yourself for GCB though.

<comment><USER18> > It's actually Cloud Build under the covers

Nope, it's actually something based on Azure Pipelines' code (on a different infrastructure)

[https://twitter.com/natfriedman/status/1159526215658561536](https://twitter.com/natfriedman/status/1159526215658561536)

<comment><USER17> Ah, that must be a change with the more recent revisions then. The original version was definitely using Cloud Build.

<comment><USER19> They swapped it post-acquisition. (Google and Github started working together more, MS acquired them, that stopped :P)

</comment></comment></comment></comment></comment><comment><USER20> If you're curious about the platforms they have: [https://help.github.com/en/articles/software-in-virtual- envi...](https://help.github.com/en/articles/software-in-virtual-environments- for-github-actions)

</comment><comment><USER21> There was a lot of hubbub over Microsoft acquiring GH a while back. Have yet to see anything negative come out of it.

</comment><comment><USER22> People will think twice when investing the time & money in develop an app for the github marketplace as if it succeed, Github could just built the app inside their system. They bought PullPanda which was good for his creator because I think it was less expensive that build that themselves.

<comment><USER23> > People will think twice when investing the time & money in develop an app > for the github marketplace as if it succeed, Github could just built the app > inside their system.

That's always a concern with platforms with attached marketplaces (heck, it's even potentially an issue with building apps for OS's, even if they don't have an attached marketplace—ask Netscape.)

</comment></comment><comment><USER24> Is it official now that Github is becoming Gitlab?

Does anyone know how they are going to bill for the compute used in the CI?

<comment><USER25> The features page has a pricing table: [https://github.com/features/actions](https://github.com/features/actions)

It is totally free for public repos. For private repos:

\- Free accounts get 2000 free minutes

\- Pro accounts get 3000 free minutes

\- Team accounts get 10k free minutes

\- Enterprise accounts get 50k free minutes

Additional runner minutes are:

\- Linux: $0.008 per min

\- Windows: $0.016 per min

\- macOS: $0.08 per min (yeah that's not a typo, it is copied straight from the page, macOS is mad expensive)

<comment><USER24> Thanks!

I'm not sure if for large open source projects, these machines will be nearly enough to run the CI jobs.

The price for Linux seems quite steep when you compare with for example what you pay with GCP.

It will be interesting to see the Github security teams catching those "public" repos doing nasty stuff like mining crypto - even with hard timeouts on each job it will be cool to see how this plays out!

<comment><USER26> For large open source projects it's free. Over time I can see them expanding their feature set including more powerful machines.

<comment><USER24> I didn't mean about the costs for large OS projects but on the requirements. As an example, in my experience, I couldn't build the `semantic` project ([https://github.com/github/semantic](https://github.com/github/semantic)) with those requirements.

</comment></comment></comment></comment></comment><comment><USER27> It always supported CI/CD, they just changed their marketing strategy from "No it's not just CI/CD" to "Yes we have CI/CD now"

<comment><USER28> What have they "always" supported exactly? I've used GitHub for a long time, but I use it entirely as a git server and sometimes an issue tracker. That said, I'm pretty sure they didn't support anything that even remotely resembles CI/CD back when I started using it.

<comment><USER29> I was using GitHub actions to do build, test and push to production for a while now, with the older syntax (the one without yaml). I'm not sure exactly what changed now, and the messaging is indeed confusing

</comment></comment></comment><comment><USER30> I wonder what they'll offer for Github Enterprise. Especially for organisations that are using it on prem and would prefer not to use Azure for builds.

Anyone know?

<comment> myself-or-not There are self-hosted Build agents and eventually this will become available inside GitHub Enterprise Server too (after it GA's)

<comment><USER31> > (after it GA's)

What's the typical latency for these kinds of features to arrive?

<comment> myself-or-not Nat just said on stage Nov 13 for GA (for GHES it will be later)

<comment><USER31> "on stage" \-- is there a Github/related conference in progress?

<comment><USER32> There was a live streamed announcement: [https://www.youtube.com/watch?v=E1OunoCyuhY](https://www.youtube.com/watch?v=E1OunoCyuhY)

</comment></comment></comment></comment></comment></comment><comment><USER33> I couldn't quickly find out if these features are now supported but what I really want is:

\- Actions can fail, but still continue (more like an additional success/failure status)

\- Manually triggered actions (maybe with parameters that need to be entered by the user)

\- Artifacts attached to actions especially HTML reports (next to plain text, this is the universal output type for a lot of quality tools)

<comment><USER34> Hi, GitHub Actions product manager here.

Thanks for your interest in GitHub Actions. You can set a property `continue- on-error: true` for each step and the runner will ignore a failed result and continue the workflow. For more details on workflow configuration please see [https://help.github.com/en/articles/workflow-syntax-for- gith...](https://help.github.com/en/articles/workflow-syntax-for-github- actions)

Workflow runs can be triggered via a `repository_dispatch` event with a custom payload. Using this model you could create a tool to allow for manual triggering. However, we do expect to provide a more integrated experience for triggering manual runs with custom inputs.

More capabilities for actions to post artifacts and reports as part of our experience is absolutely on our radar.

We are working to bring as many new users into the beta as quickly as we can and we look forward to your feedback.

</comment></comment><comment><USER35> Really interesting. My project just migrated to Azure DevOps and I noticed that their configuration file looks really similar. My suspicion is that Azure DevOps is backing GitHub CI/CD.

<comment><USER36> Hey there, I'm the Director of Engineering at GitHub with the team working on Actions. We really wanted to get an extremely flexible and powerful SDLC automation platform into our users hands as fast as possible. To do that we borrowed some code and infra from Pipelines to be able to offer a rock-solid CI/CD to every developer on GitHub sooner, and to be able to scale out to 40 million developers. With hosted runners, you'll be able to run your Actions builds in any cloud, or even on your own hardware; if you don't want to set that up, builds run on VMs and containers in Azure by default. You can use Actions to deploy anywhere and we have AWS, Azure, and Google Cloud actions to enable you to get started right away. If you want to read up a bit more about our virtual environments as well as what powers our runners check, we have some of that info in our docs here: [https://help.github.com/en/articles/virtual-environments- for...](https://help.github.com/en/articles/virtual-environments-for-github- actions).

<comment><USER37> I feel like everyone who uses MS these days and still doesn't carry over distrust cultivated in the 90s knows that the problem isn't going to be lock in. But I'm sure MS's end game is to make you _want_ to use Azure more, which is fair game.

</comment></comment></comment><comment><USER31> Free CI/CD for repos public and private is one thing that makes Gitlab really attractive to me. If Github's is simple/sane enough I would probably consider that also.

<comment><USER38> I've been using GitHub actions for my personal projects for the past few months. The documentation was not the best and the UX was not polished at all, so the experience was painful sometimes. A lot of my problems will be solved with the features announced today, except I'm not sure if they're also adding a way to cache e.g. dependencies between jobs.

While writing your own actions was painful (at least for me), reusing actions that other people wrote worked like magic. I think the reusability aspect is going to be huge when Actions get more and more popular.

</comment></comment><comment><USER39> I do not understand why Microsoft finances this. I understand the hosting as a specialized social platform, but GitHub Actions vs. Azure DevOps Pipelines are a duplicated effort. Better integration for GitHub for the Azure DevOps suite would solve that in a similar way without duplication of capabilities.

<comment><USER40> All roads lead to Azure. Github's user base is far bigger than Azure's user base, and Microsoft wants to eventually get as many people as possible buying IaaS (or equivalents).

The next logical step after Github Actions for CI/CD is to offer Github as a place to run the production code too. You would be buying Azure with fewer steps. It's pretty arbitrary that we develop code in one place while then going off and using a separate suite of tools and processes to run it. Having a suite for everything in one place could be very appealing to the market.

<comment><USER41> If they added a button that was essentially just zeit now it would be revolutionary. Especially if they had a generous free tier. Imagine one click hosting for blogs, etc. Now THAT would certainly hook people in

<comment><USER42> That sounds a bit like Github Pages which has been a thing for a while.

<comment><USER43> Sure, if your site is solely static content, which is all GitHub pages supports. You can't run "production code".

I know some people use the service with a static site generator as a free way to host a blog, but it's not really the same thing at all.

<comment><USER44> Works pretty good for blogs and in general if you use serverless tech.

However i wouldn't consider it for mission critical stuff - github's infrastructure can't be compared to actual paid-for cloud hosting.

<comment><USER45> > github's infrastructure can't be compared to actual paid-for cloud hosting.

I think the idea in this thread is that since github is owned by MS, and they have Azure, that won't be an accurate statement for very long. Github doesn't have to build that infrastructure, they just need to competently integrate into MS existing infrastructure.

I can't believe I didn't piece this together sooner but I agree with this threads premise. I'm already hosting my source on Github so why not build it there? And if I'm building it there then why not deploy it there? Rather than manage a complicated pipeline, I just `git push` and everything else just works ... all the way to massive scale.

As someone who has worked on hand-built github to AWS pipelines ... I can actually see this being the killer feature Azure needs to actually win a large market share.

</comment></comment></comment></comment></comment></comment></comment><comment><USER46> [https://twitter.com/anoff_io/status/1159512381728407552](https://twitter.com/anoff_io/status/1159512381728407552)

True? microsoft person on stage [https://devblogs.microsoft.com/devops/author/jeremy- eplingou...](https://devblogs.microsoft.com/devops/author/jeremy- eplingoutlook-com/)

Sorry Github! Not good!

</comment><comment><USER47> Meanwhile, I still haven't been invited to the beta...

<comment><USER47> Seems like complaining on HN works, I've been invited!

</comment></comment><comment><USER48> I've been on the beta for a while, and while it was understandably limited, I really enjoy it and have done a lot with it. I'm excited about the announcement because it appears that a lot more can be done now.

However, it's not clear what happens to existing actions and workflows. Do they just stop working? Can actions still be made from a dockerfile and entrypoint script?

<comment><USER49> See -

[https://twitter.com/gimenete/status/1159521518403145728?s=20](https://twitter.com/gimenete/status/1159521518403145728?s=20)

[https://help.github.com/en/articles/migrating-github- actions...](https://help.github.com/en/articles/migrating-github-actions-from- hcl-syntax-to-yaml-syntax)

Already used the "migrate-actions" binary on a few projects, and while I don't have the new version enabled (you'll get a notification when the repo is available for an upgrade), this is better in terms of simplicity since you don't have to manage action references or the "resolves" field (when you were manually editing the hcl).

The only downgrade is that it doesn't look like you can run actions in parallel within the same "job"; so you can't have eg. "cd project1 -> npm i" and "cd project2 -> npm i" running at the same time and then have a third action that can use the output/filesytem of both of those commmands. Now the "job" will run one, wait for completion, then run the other, then you can have an action that uses the changes of those.

<comment><USER48> Thanks for the links! I'll miss the old workflow and its syntax (allowing for parallelism), but I'm keeping an open mind.

</comment></comment></comment><comment><USER50> Free 2,000 minutes per month, not bad. No info about ssh debug - top feature for any CI service.

<comment><USER51> Appveyor also support stop and RDP in the windows build agents for 60 minutes each build. really nice for diagnose the issues

</comment></comment><comment><USER52> Lots of comments here about what this means for CircleCI. Found it interesting that CircleCI's CEO has a testimonial in the "What our community is saying" at [https://github.com/features/actions](https://github.com/features/actions):

"CircleCI has been building a CI/CD platform since 2011, and GitHub has been a great partner. GitHub Actions is further validation that CI/CD is critical for the success of every software team. We believe that developers thrive in open, connected ecosystems, and we look forward to working with GitHub to lead the evolution of CI/CD." Jim Rose CEO of CircleCI

<comment><USER53> That's kind of a content-free statement, unfortunately.

Although it's possible they can successfully position themselves as the premium upgrade, it's hard to see how this isn't a threat to CircleCI.

</comment></comment><comment><USER54> I work for Codefresh a CI/CD solution for Kubernetes/Helm/Docker.

One of our main goals when creating Codefresh was to make plugins that are not tied to Codefresh itself. As a result we followed the obvious model with plugins where they are just docker images and nothing else.

[https://steps.codefresh.io/](https://steps.codefresh.io/)

We are very glad to see that Github actions follows the same model. This means that we instantly get all Github actions as possible Codefresh plugins (and the opposite).

I would be really happy if other CI companies follow suit so that eventually a central CI/CD plugin repository can be created for all competing solutions.

</comment><comment><USER55> Woahhhhh, MacOS support? That's enough for me to switch from CircleCI right now. $40/mo to Circle is just a lot to do CI/CD for some React Native apps, with CD only getting kicked off once a week or so.

</comment><comment><USER56> I really want to try GitHub Actions but I signed up as soon as it was released and I am still waiting for an invite.

I am mostly just excited for it to be released so I can try it.

<comment><USER57> Hi! I just looked and we can't find you on the beta list, for some reason. Sign up and then DM me when you have (@_clem).

</comment></comment><comment><USER58> This "sounds" interesting, and I'd absolutely love to manage ci/cd in github. Can anyone point me to some clear docs or articles on its usage? The blog post and developer guide on actions reads like some hybrid of a marketing page and a plain index of terms. Most of the examples on workflows/actions documentation and the like are in HCL which is being deprecated.

<comment><USER36> Once you're in the beta, you'll be able to get started by picking from a varying list of templates. In the meantime, those templates are actually hosted here: [https://github.com/actions/starter- workflows](https://github.com/actions/starter-workflows). Depending on what you're interested in setting up, this page might be helpful in getting started. [https://help.github.com/en/categories/automating-your- workfl...](https://help.github.com/en/categories/automating-your-workflow- with-github-actions)

</comment></comment><comment><USER59> I scanned through, but I couldn't see how GitHub Actions supports deployment to 3rd party platforms like PyPI.

Travis CI has a CLI that allows you to encrypt your PyPI password and stick it into the Yaml file (I think it works by encrypting your password and then uploading the decryption key to your Travis account). Will GitHub Actions have something similar, somehow?

<comment><USER60> GitHub Actions supports secrets in each Repo. So presumably you could just expand your secrets at runtime and use a CLI tool to push to PyPI.

</comment></comment><comment><USER61> You lost me at YAML..

<comment><USER62> What would you like instead? Personally, for those type of things I never thought yaml was limiting in any way, but would be keen to hear what better options you think are out there. I like the simplicity and readability of yaml, as long as there's not too much logic to be expressed.

<comment><USER63> I think the future is that all configuration is code. Code in a proper functional/imperative language (preferably the one you wrote the app code in), rather than a special declarative language. The attraction of toml is minimalistic and simple definitions initially - but there is _always_ too much logic for these languages. If not immediately, then eventually.

"Real" programming languages have good compilers, good error messages, debuggers, IDE's with syntax highlighters and so on. json/yaml/toml/xml/whatever always feels like you are poking something and then trying it, checking for errors from typos and starting over. This feels quite backwards if you are used to developing with a good strict compiler and debugger.

There are projects like pulumi that provide API's for multiple languages and hook into almost any service (e.g. Azure, AWS)

[https://www.pulumi.com/](https://www.pulumi.com/)

<comment><USER62> Yeah, I know pulumi, and I'm working on something similar myself. Personally, in my experience, I don't think there's _always_ too much logic, far from it.

A lot of times you really only have a list of tasks that are executed one by one, and the nature of that doesn't really change. I think it's overkill to introduce a new wrapping layer in those cases (and that is what Pulumi really is, it mostly just wraps Terraform if I understand right). But yes, sometimes it's better to have 'real' code at your disposal. It's just a matter to know when's when. Like always :-)

Also, debugging those yaml problems or real code doesn't really seem to make a difference for me. It's both equally annoying, and since there is a 'declarative' layer involved most of the time anyway, just a bit deeper down, debugging the 'real' issues (not typos and such -- btw. check out yamllint if you don't know it) is not any easier with wrappers like Pulumi. But maybe we have just worked on different type of complexities in our pasts. That usually explains different preferences for tooling. Just saying that this is not a thing we should/can generalize.

</comment></comment></comment></comment><comment><USER64> Sadly my company's account hasn't been granted access yet :( We are currently evaluating a switch from our current CI/CD platform and this would have been perfect. Can't wait for November general availability!

</comment><comment><USER65> Can GitHub Actions be used on open-source repositories maintained by organizations?

<comment><USER28> When I clicked the link to sign up for the beta, it let me select my personal account or the one organization account that I own. So based on that I strongly suspect that the answer is yes.

<comment><USER65> Ah, thanks. Just so happened that I don't have the required admin permissions to enable Actions on the organization I was interested in.

</comment></comment></comment><comment><USER66> Considering CircleCI has many more years in operation, are there features and use cases it supports that GitHub Actions doesn't? Are there ones that GitHub Actions already supports that CircleCI doesn't?

</comment><comment><USER67> GitHub is way late to the game here. I personally have started moving away from GitHub. They don't even offer an open source version, yet try to claim to be some gift for open source. GitLab is better, but their architecture is a bit more complicated than it should be. I really like sites that use Gitea, but they haven't integrated CI/CD like GitLab, nor have they proven to scale with their own hosted solution. When I think about the point of these solutions though, there is a lot of opportunity here. Heck, Git is decentralized and distributed by itself. Really people just want a place to manage their issues and MRs, and I hope someone will decentralize that with a native app and then add additional features that integrate into multiple providers with ease.

</comment><comment><USER68> That's awesome! I've always been a big fan of GitLab CI but I'll have to take a look at this and see how it stacks up. Competition has proven to be good for the market of Git hosting platforms.

<comment><USER68> Wait, why'd I get buried for this one? I know it's against guidelines to discuss karma but I am just genuinely puzzled and nobody left any comments.

</comment></comment><comment><USER69> That's pretty huge. I wonder if it's possible to have the results committed to the repository. To be able to display a badge in the readme. Like 87% test passing.

<comment><USER70> Hi, Coveralls CTO here, the pass/fail status of any commit is shown as a green check / red x in the commit list and at the top of the repo details page as the "most recent commit".

As for a % badge, you can use our new Coveralls GitHub Action to post your coverage data to [https://coveralls.io](https://coveralls.io), then add the badge to your readme:

[https://github.com/marketplace/actions/coveralls-github- acti...](https://github.com/marketplace/actions/coveralls-github-action)

</comment></comment><comment><USER71> I've been on the wait list for many months and still haven't gotten a chance to join the limited public beta.

</comment><comment><USER72> I remain incredibly happy with Semaphore CI and don't see this as a value improvement.

<comment><USER73> I don't love the yaml of its 2.0 version. The visual build steps is horribly horizontal (why not just wrap it vertically?).

</comment></comment><comment><USER74> That seems really cool! I wish I wasn't still on the wait list so I could try it out.

</comment><comment><USER75> It seems to be very expensive. About 6 times more expensive than Semaphore 2.

</comment><comment><USER76> CircleCI must be sweating hard. They're probably looking for a buyer.

<comment><USER26> They just raised more funding in a Series D[1]. CircleCI isn't the only player in the space and GitHub entering the playing field doesn't change that either. There's enough space for a few competitors and having competition will probably push everyone to build a better product.

[1] [https://circleci.com/blog/we-raised-a-56m-series-d-what-s- ne...](https://circleci.com/blog/we-raised-a-56m-series-d-what-s-next-for- circleci-customers/)

</comment></comment><comment><USER77> Very excited to use this for deployment to AppEngine!

</comment><comment><USER78> It is waiting list, not a product.

</comment><comment><USER79> only allowed users by USA

<comment><USER80> Nope, I'm in Germany and I was in the closed beta or quite some time. The UI improved dramatically in the last months.

</comment></comment><comment><USER81> Github blog [https://github.blog/2019-08-08-github-actions-now- supports-c...](https://github.blog/2019-08-08-github-actions-now-supports-ci- cd/)

<comment><USER82> Thanks! We've updated the link from [https://help.github.com/en/categories/automating-your- workfl...](https://help.github.com/en/categories/automating-your-workflow- with-github-actions).</comment></comment>


Realistic fusion drive with Epstein Drive-like performance - lachlan-sneff https://toughsf.blogspot.com/2019/10/the-expanses-epstein-drive.html <comment><AUTHOR> Everyone who has not watched The Expanse yet: start doing it. It is easily the best SciFi show in the last decade and a top contender for best SciFi show ever.

It has a slow start but is increasing pace and when you realize you are being watching seasons you are doomed because soon the year long wait starts :)

<comment><USER2> The books are really good, too.

I need to watch the series at some point.

<comment><USER3> I not sure how many realize this, but the books were actually written by a team of writers, well 2 writers, in parallel, defining the world, characters, and storylines. James S.A. Corey is the pen name of authors Daniel Abraham and Ty Franck. Great series too :)

<comment><AUTHOR> And it get really interesting who their friends are down there in New Mexico :)

</comment></comment></comment></comment><comment><USER4> take a fictional propulsion technology from [Sci-Fi TV show, movie or book] and apply the appropriate science to explain its features in a realistic manner

Doesn't everyone do that or is it just me? I always try my best to think of a way that such things could work.

<comment><USER5> That's how I watch magic and mentalism acts as well. Until now, I'd not considered such a similarity between Darren Brown and Geordi La Forge.

<comment><USER6> With the caveat that magic and mentalism don't actually work, but only appear to work. So a better analogy might be between magic/mentalism and those fake perpetual motion machines which appear to work but don't.

</comment></comment></comment><comment><USER7> Is it fair to call the Rocinante a time machine? If it can achieve 5% of C in 37 hours it can go seriously relativistic in a reasonable amount of time. It becomes possible to travel across hundreds or thousands of Earth years in a lifetime, like Andrew and Valentine Wiggin or Colonel George Taylor.

The travelling through space feature is pretty cool too though.

<comment><USER8> If you want to go relativistic, you'll have to deal with the fact vacuum is not as perfect as you'd like it to be. You'll need some form of abrasion shield because you'll be hitting a thin wall of hydrogen at relativistic speeds.

<comment><USER9> Bussard ramjet:

[https://en.wikipedia.org/wiki/Bussard_ramjet](https://en.wikipedia.org/wiki/Bussard_ramjet)

<comment><USER8> If the field manages to catch everything in the ship's path, that's good, but not all particles will cooperate. You'll catch some, push others out of the way and still get hammered by all the stubborn neutrally charged ones.

And that's only for the atomic scale. Smashing into a grain of dust at a relativistic speed is very destructive.

</comment></comment></comment></comment><comment><USER10> They really did sell everything at Radio Shack back in the day.

</comment><comment><USER11> It's gratifying seeing a discussion that focuses on the central problem of waste heat control.

</comment><comment><USER12> An "engineering challenges with today's technology" section would be great addition to this piece, I'm sure there'll be a few "biophysically possible but we don't know how" parts ;)

</comment><comment><USER8> Would the heat absorbed by the heat shield be enough to power the igniter and the magnetic field?

Worst case scenario would be to use the heat to power a thermal rocket. Not an efficient use of propellant, but still doable.

</comment><comment><USER13> Assuming 100% combustion of fuel is not realistic, especially with fusion.

<comment><USER8> If the engine manages to get half as much useful thrust out of the fuel, it's still a nice 1g all the way to your destination. Still quite a revolution.

How much would be realistic?

<comment><USER13> Maybe 2%? That's based on yields common in nuclear weapons of this complexity. Fusion should be even harder to contain above critical temperatures.

<comment><USER8> Well... I guess even .04 G can be useful... And if we are only fusing 2%, we can bring the reaction to much closer to the ship itself.</comment></comment></comment></comment>


Ransomware Decrypts Your Files If You Play PlayerUnknown's Battlegrounds - <AUTHOR> https://www.bleepingcomputer.com/news/security/pubg-ransomware-decrypts-your-files-if-you-play-playerunknowns-battlegrounds/ <comment><USER2> It could be nice to have a ransomware that decrypts your files once you followed a tutorial on how to backup your files. Or something that make you go through general security best practices.

(just some wild thoughts I had)</comment>