Julia Computing has a new product called JuliaTeam. Currently it lets developers install Julia packages behind a company’s firewall without hassles while hooking into authentication systems so that IT and management have insight and control over who’s using what Julia packages. We’ve written about it in our newsletters and customers are already trying it out.
Our plans for JuliaTeam are much bigger than this simple beginning, however: it will provide key infrastructure for the whole Julia ecosystem and be a mechanism for companies benefitting from that ecosystem to give back to the community. Not out of some sense of altruism or charity but for good old fashioned capitalistic reasons — because it saves them money. The vision of JuliaTeam is to create a virtuous cycle between Julia’s open source ecosystem and companies deriving value from that ecosystem.
This is the JuliaTeam business model in simple terms: build high quality services for all Julia developers, give them to open source projects for free and charge companies for those services integrated nicely into their corporate environments. We see a lot of commercial demand for great services that make developers more productive; the very same productivity boost is also needed to accelerate open source development, which in turn provides greater value to everyone using Julia. In addition to including private versions of public services, the JuliaTeam product integrates smoothly into each company’s development environment—authentication systems, internal code hosting, issue trackers, application deployment — all wrapped up in a clear, high-level dashboard.
JuliaTeam will also give us visibility into which open source packages companies rely on. This helps us understand what the most important packages are and puts us in a position to ensure that these packages are maintained and funded appropriately. We envision a future where Julia Computing can reinvest revenue from JuliaTeam into the open source ecosystem, providing support to make sure that releases, bug fixes, documentation, and testing all meet the highest standards for software development.
Enough high-level vision talk, what is JuliaTeam? What functionality does JuliaTeam already offer? What will it include in the future? Each capability of JuliaTeam comes in a free open source flavor and a corresponding paid enterprise flavor. The following list outlines some of these capabilities with an indication of whether each one is “done”, “in progress” or “on the roadmap”.
Installation [done]. JuliaTeam serves registry info, package source, binary dependencies and other artifacts. Instead of trying to fetch these from a smattering of different servers across the Internet which may go down, go away, or be compromised, Julia package clients fetch from a secure, maintained JuliaTeam instance. This avoids firewall issues and offers security, visibility and control. JuliaTeam replaces a mix of GitHub, GitLab, Bintray, random FTP servers, and other miscellaneous sources for serving code and release artifacts. Having a single managed service will be safer and more reliable and allow the Julia community to get valuable (anonymous) telemetry about how often packages are installed and upgraded and on what platforms; currently we don’t have access to this information. This JuliaTeam service is already in use by thousands of JuliaPro users — JuliaTeam serves up all packages installed by JuliaPro.
Backup [roadmap]. Long-term copies of all registered code will be stored in case someone deletes a package repo or original versions of required artifacts — whether on purpose or by accident. This prevents “left-pad” scenarios. JuliaTeam thereby minimizes the damage that a disgruntled or fat-fingered developer can cause. Since Julia package versions are addressed by identity and content-addressed in manifest files, once a version is saved, it never has to change. The JuliaTeam instance serving packages to JuliaPro users already provides some degree of protection from potential left-pad situations, but we plan to build out fully resilient, long-term backup system for both public and private packages.
Security [in progress]. Ensure that if there are security vulnerabilities discovered in any Julia packages that you are using, you are made aware and can react in a timely fashion. There have been a number of security compromises in the package systems of open source programming languages in recent years. Having proactive auditing and notification when a compromise is detected will help keep our entire community safe.
Registration [in progress]. The open source Julia ecosystem is currently in a slightly awkward state where packages are still registered with the old METADATA.jl repository, which is automatically synced to the new General package registry; the new registry is used by Julia ≥ 0.7 to install packages. This arrangement has the benefit that it allows users of both old and new Julia versions to continue to use all registered packages, but it’s getting to be time to register new package versions directly with the General registry. A new package registration process is under development, which JuliaTeam will include to support registration of private packages inside of organizations.
Compatibility [in progress]. For several months now, requests to register new versions of packages have been checked automatically and merged if they pass sanity checks including passing their own tests and not breaking the tests of any reverse dependencies that they claim to be compatible with. This has been very successful but the service is quite hard to keep running (it’s currently down and undergoing long term maintenance, for example). An updated version of this service will be integrated into both the public and enterprise JuliaTeam registration processes, which will help prevent unintended API breakage.
Documentation [in progress]. Providing a single place to find all documentation for the Julia packages that you use. This service offers a single consistent place and way to host and publish package documentation. It also makes cross-linking docs between packages easy since they all live in the same place. Developers shouldn’t ever have to set up or think about the how of documentation hosting—they should just need to follow standard conventions for inline docs and then push their code. The docs service does the rest: cross-linked, searchable (see the next bullet point) docs are generated automatically. Those who are interested in following along or contributing are encouraged to checkout the work-in-progress DocumentationGenerator.jl package.
Search [in progress]. Currently search and discovery of packages is a serious pain point in the Julia ecosystem. JuliaTeam will provide integrated search of documentation and code for all packages. This will let you find the package that does what you need, whether it’s a public open source package or a private package that your organization uses—they’ll all be searchable in a single place. Code search will match the capabilities of the Google Code Search of old.
Refactoring [roadmap]. One of the major difficulties of refactoring code bases composed of many packages is updating all the components at the same time. The right tooling, however, can make this much less painful—even smooth. We envision being able to change an API and easily make a set of coordinated changes across all packages that use the API. The Julia community has already experimented with this approach with the FemtoCleaner bot which helped update public packages for Julia 1.0.
Upgrades [roadmap]. When doing Julia releases, we test all registered open source packages on release candidates and investigate any failures to determine whether we’ve inadvertently broken compatibility where we shouldn’t. Even when packages rely on unstable Julia internals, we make updates to those packages so that a working version already exists by the time the new Julia version is released. JuliaTeam will allow private packages to get the same kind of testing, which lets us guarantee that the next release of Julia won’t break your applications, enabling you to upgrade without fear.
Testing [roadmap]. Smart, Julia-specific continuous integration. Projects that use standard Julia testing tools will fit into JuliaTeam transparently, allowing us to present test results in a clear way that can be drilled into easily. In will also also be possible to analyze code changes and prioritize tests so that tests that are most likely to fail are run first, massively reducing test time when tests fail, improving both developer productivity and utilization of CI resources.
Debugging [roadmap]. When some test fails during CI, it’s often a time-consuming nightmare to reprodce the failure in a way that can be debugged. Instead of wasting developer time trying to reproduce the circumstances of such a failure, we want to allow the developer to log into the CI server directly and get a Julia debug prompt right at the point where the failure occurred. With rr integration, we could even allow developers to step backward in time in the debugger from the error to find the origin of the problem. Imagine debugging with superpowers without the inhuman setup process.
Benchmarking [roadmap]. Julia users care about performance. It’s one of the major selling points of the language, after all. (“Come for the speed, stay for the multiple dispatch.”) Julia Base has infrastructure for measuring and tracking performance of code over time, but Julia itself is not the only thing that needs benchmarking. We’d like to build a similar system for benchmarking all kinds of Julia projects to help people make sure their code is fast and stays fast.
As you can see, we have quite a few features planned for JuliaTeam. Some are already done. Many are well under way. And some of the most exciting ones that might completely transform the way Julia development is done are in the future. If you want to try JuliaTeam out today, contact us by emailing [email protected]. If you have ideas for other services and features that you feel that you and every other Julia developer need, please let us know. We will publish more blog posts in the future as we develop and release more features for JuliaTeam. We can’t wait to get these services built and help Julia developers everywhere make amazing software faster and easier!