Galois Blog

Igalia (https://www.igalia.com), also Spanish, is a fairly prominent tech company that is also a co-op. Galois, Inc. (https://www.galois.com) is employee-owned, and they do lots of great formal methods work. But not sure whether this model is appropriate for a startup. I guess splitting stock more evenly is a good starting point.

They don't seem to mention it on their site, but Galois[1] is an employee-owned cooperative with an internal governance structure that reflects that mutual ownership. I don't work for them, but I've worked with them for the last four years and it's been great. [1]: https://galois.com/

I certainly agree that both groups have bridged the gap. Haskell is one of the best tools available when you absolutely have to get programs correct. Companies like Galois[1] for example are big Haskell users. I think it's very practical. Haskell has also renewed interest in a branch of mathematics, category theory, that has helped understand problems in mathematical foundations and recently even physics. Also, not to quibble, but I think it's been around since the late 80s. I can check my library but I believe the original report (I have a hard copy) was issued on April fools day. [1] http://www.galois.com/

I would check out https://pedestrianobservations.com/ for information on other but analogous cost disease. Basically, no, it's not just a meme. American managerial culture (or even Anglosphere at large, as alleged there) really does suck. And no amount of crafty mechanism design gets around the fact that least exploitable system seems to be one where the civil service isn't maimed and the work is done in-house. Basically government should fund some free software for various general purposes (or just do a decent UBI), and then any "consulting" should basically be public sector and free software sector exchanging best practices. The higher end academic consulting (ARPA) is legit[1] and should still exist, but it shouldn't be defense specific, and like drug bounties basically should exist to smooth over the "research...development...product" gap --- development is severely sort-changed current since outside of DARPA and ARPA-E so much research that doesn't contribute to someone's rent-seeking agenda just lies wasted. [1]: I suppose should say I once was an intern at https://galois.com/

I had seen this company web site some years ago. https://galois.com/

It's true that engineering principles are not usually applied in the software field, but if quality is the most important requirement, they are indispensable. Example: https://galois.com/ Example: https://inst.eecs.berkeley.edu/~cs162/sp13/hand-outs/They-Write-the-Ri…

There are a few consulting companies that specialize in this. For example Galois [1], with offices in several US cities. In the UK there is (or was) Praxis [2]. (I have never worked with either, I have just heard of them). 1. https://galois.com/ 2. https://en.wikipedia.org/wiki/Altran_Praxis

Author here. If anyone isn't familiar with Galois, we're a consultancy that does a lot of formal methods and proof, which is why it would be great if proofs were easier to manage :) If you're curious, you can get a sense of what we do here: https://galois.com/blog/2021/02/2020-year-in-review/ The tool we use most often for proofs is called SAW: https://saw.galois.com/

Software Engineer/Researcher @ Galois | Portland, OR, Arlington, VA, Dayton, OH. Remote is also a possibility. Galois is looking for software engineers and researchers that enjoy working on challenging problems in computer science. We work with organizations like DARPA to explore blue sky ideas and turn them into usable technology that guarantees trustworthiness where failure is unacceptable. We own the company together (through an ESOP), we make important decisions as a group, we have a one-level flat organizational structure, and people get to choose what they work on. We love to learn and share what we know, and that’s a big part of how we approach R&D, so we have no hard requirements for previous experience with similar work. We think working here is awesome (See https://lifeatgalois.com) To apply: https://galois.com/careers/software-engineer/

Oh yeah, Galois is another one of the greats in the field. They just keep cranking out one practical thing after another. At a higher pace than most it seems. Here are a few good things on their end. Scrolling their blog is endless insights https://galois.com/blog/ CRYPTOL's open source page http://www.cryptol.net/ SMACCMPilot has things like Ivory language http://smaccmpilot.org/ GitHub site with 8 pages worth of their stuff https://github.com/galoisinc

Here https://www.facebook.com/ Here https://galois.com/ And Here https://www.fpcomplete.com/ To name a few.

Galois has a pretty flat structure, and employees can choose what they work on among the currently funded projects (they do mostly grant-funded research). https://galois.com/

Just to follow up on this, Edward himself is giving a tech talk on Tuesday, on SAT solving: * http://www.galois.com/blog/2010/08/19/tech-talk-abcbridge-functional-i… Also, videos of other tech talks at Galois are up on vimeo: http://vimeo.com/channels/galois Edward's been an amazing intern. He'll do great things.

http://www.galois.com/ is a mostly haskell shop. It's definitely an interesting language; but I would see it as more competitive with C, C++ or Java as a language for building high reliability components.

I worked on a blockchain that used formal methods as part of the development workflow. The development process was essentially writing a paper that formalised an algorithm or a protocol, an implementation in Agda that would generate Haskell (or written straight in Haskell), property based tests against the paper, and then a whole business analysis/QA side where there'd be a requirements matrix against the paper with unit/integration/end-to-end tests on the features too. So you'd end up with formally checked code, property based tests, unit tests, integration tests, end to end tests, manual checks, and a few other tools too. This was a pretty slow process but on the two major product releases I worked on, I can only remember one bug slipping through and that was patched before people realised (and not a major issue either). So I think this style of development can work if you can 1) afford it, 2) afford the time to do it, and 3) formulate the requirements in such detail upfront. Here's an example of a formal method paper that explains how a specific protocol works: https://hydra.iohk.io/build/13099985/download/1/blockchain-spec.pdf This is a fun example of doing something similar with Coq to build a porn browser: http://www.michaelburge.us/2017/08/25/writing-a-formally-verified-porn… And there are a couple companies out there that do this style of development as a consultancy - it's probably the closest to 'engineering' that software development can get…

The transpiled code will use pointers, it will not transform C-isms that could map to Rust-isms (like borrowing instead of pointers, or iterators instead of pointer arithmetic). This is meant to be only the first step in a Rust refactor. https://galois.com/blog/2018/08/c2rust/ https://github.com/immunant/c2rust/wiki/Known-Limitations-of-Translati…

If I recall correctly, Galois also got involved in a DARPA initiative a few years back (HACMS [0]) to create un-hackable UAVs (drones) - use the Haskell type system to produce non-vulnerable C code [0] https://galois.com/project/hacms-high-assurance-cyber-military-systems…

Note that existence of a formal proof for security is no silver bullet. A real world example of this is the WPA2 key exchange's formal proofs not catching the KRACK vulnerability. https://galois.com/blog/2017/10/formal-methods-krack-vulnerability/ That being said, it's a very valuable tool and should be applied more, not less.

You can't prove that something is secure, because to be applicable in mathematics/computer science there has to exist a precise definition. If someone is just saying "This is a formally verified protocol" without what they actually checked for, they are salespeople not mathematicians. "The authors of the KRA paper were able to understand what the proofs were about, and why they don’t cover the KRACK vulnerability. Even though the original proofs didn’t reveal security flaws, a principled approach would use these proofs in order to discover where to look." https://galois.com/blog/2017/10/formal-methods-krack-vulnerability/

Name me a single company that uses Haskell 2010. It's completely irrelevant. But I'll leave you to argue with Vitaly Bragilevsky (speaking at Galois): "Haskell is a big language" -- https://galois.com/blog/2018/11/teaching-haskell-in-the-real-world/ Or Paul Hudak, Philip Wadler, and Simon Peyton Jones: "Haskell is a big language" -- https://www.microsoft.com/en-us/research/wp-content/uploads/2016/07/hi… (p.28) Maybe those guys know something. It's cool Haskell goes through a small IR. That doesn't make TH, rewrite rules, CPP, the million extensions, STG, the runtime, the gigantic syntax, or the quarter million SLOC implementation simple.

A few links found by following up: https://xenaproject.wordpress.com http://wwwf.imperial.ac.uk/~buzzard/one_off_lectures/msr.pdf http://aitp-conference.org/2019/slides/KB.pdf https://galois.com/blog/2018/07/the-lean-theorem-prover- past-present-and-future/ https://florisvandoorn.com https://florisvandoorn.com/talks/JMM2019formalabstracts.pdf https://sites.google.com/site/thalespitt/ https://jiggerwit.wordpress.com/2014/05/21/27-formal-proof-projects/ https://jiggerwit.wordpress.com/2016/10/18/elliptic-curve-addition-wit… https://arxiv.org/abs/1610.05278

AP article on this: https://www.apnews.com/7e78189c21ce4a7cb7cb73432705c3ca (via https://news.ycombinator.com/item?id=19844173) And the Galois post here: https://galois.com/blog/2019/05/protecting-election-integrity-with-ele… (via https://news.ycombinator.com/item?id=19840683)

Galois has a reputation for being one of the most visible and well-known shops associated with Haskell. I'm curious to see what they can accomplish. A little bit of poking showed this[0] coming up -- I definitely wonder if that's around the same direction they'll be taking. [0]https://galois.com/project/csfv-crowd-sourced-formal-verification/

Then you probably don't appreciate what tree-sitter has to offer. https://galois.com/blog/2017/12/tree-sitter-new-parsing-system-program…

The project is developed by Galois. From their website[1], "Galois is a privately held U.S.-owned and -operated company established in 1999 in Portland, Oregon." So they started at probably one of the worst times to start a tech company (right at the dot-com bust) and are still around. That says nothing about whether Ivory will get any traction, but at least there's an apparently stable company behind it. [1] https://galois.com/about/

Galois uses their HaLVM on Cyberchaff. https://galois.com/project/cyberchaff/ The TCP/IP stack from Docker is based on MirageOS code. https://blog.docker.com/2016/05/docker-unikernels-open-source/

Saving the next person the time. Links to both: Copilot https://galois.com/project/copilot/ Cryptol https://en.wikipedia.org/wiki/Cryptol

The article mentioned that the project includes formal verification. From a moment scanning Galois' web page: https://galois.com/research-development/software-correctness/

It's beyond experiments now and there are clear uses for such things. For example, a recent post describes using MirageOS to build a firewall VM [1]. There are also network security/intrusion-detection systems [2]. There are a number of ways to build unikernels and they're not all OCaml (which is just MirageOS) -- http://unikernel.org is trying to bring these together. [1] http://roscidus.com/blog/blog/2016/01/01/a-unikernel-firewall-for-qube… [2] https://galois.com/project/cyberchaff/