Hello, Habr! I present to you the translation of Stephen Wolfram's post .
The prerequisites for the viability of the Wolfram Language
Today we stand on the brink of great achievements together with the programming language . Just three weeks ago we launched , to help our users integrate the Wolfram Language into their large-scale software projects. Today we are launching , to provide a coordinated platform for functions created to extend the Wolfram Language, and we are also opening the function repository to anyone who can contribute to the development of our software product.
The Wolfram Function Repository is what has become possible thanks to the unique characteristics of the Wolfram Language not only as a programming language but also as . In traditional programming languages, adding significant new functions usually involves creating entire additional libraries that may or may not work when used together. However, in the Wolfram Language , that there is the potential to significantly extend its functionality simply by adding new functions that immediately integrate into the overall structure of the language.
For instance, right now the Wolfram function repository contains organized into 26 thematic categories:
Similar to more than , built into the Wolfram language, each function in the repository has a documentation page with detailed descriptions and examples of use:
To access the page, copy the provided object (function BLOB), paste it into the input line, and then run the function ā it is already built into the Wolfram language and is supported by default starting from :
It should be noted that when processing You do not need to, for example, set up an 'image processing library' ā as we have already implemented a consistent and carefully algorithmized method for , which can be immediately processed by various graphic functions of the language:
I hope that with the support of , which has been growing and expanding (based on the Wolfram Language) for the past few decades. The Wolfram function repository will significantly broaden the range of functions available in the language in the foreseeable future, potentially offering specialized functions in various fields of science and technology. Thus, it becomes possible to utilize both the content of the language (its built-in functions) and , which are implemented based on the language. (It is worth noting that the Wolfram Language has over ).
Inside the functions from the repository, there may be small or quite substantial code segments written in the Wolfram Language. For example, these could be calls to . A unique feature of this approach is that when you transition to user-level functionality, there will be no potential mismatches because this approach is based on a consistent structure of the Wolfram Language ā and each function will automatically work correctly ā just as it should.
The shell and software structure of the Wolfram function repository are set up so that everyone can contribute to the common cause in the simplest and most convenient way for them ā essentially, just . Built-in automated functions allow for the verification of newly added functions in the repository to ensure their guaranteed integration into the language. Our company focuses on a wide range of users who can integrate their functions into the language rather than on the complexity of new functions ā and while there is a verification process in place, we do not insist on anything like or strict standards of completeness and reliability for new user functions, unlike the more thorough checks for functions embedded in the core of the language that we apply.
This approach involves many compromises and details, but our goal is to optimize the Wolfram function repository for user convenience and to ensure that new user functions make a significant contribution to the development of the language. As we grow, I have no doubt that we will need to invent new methods for handling and validating embedded functions within the repository, not least to organize the large number of functions and find those needed by users. However, it is encouraging that the path we have chosen is a good start. I personally to the initial base. Many of them are based on code that I have personally developed over a considerable period. And I spent only a few minutes to forward them to the repository. Now that they are in the repository, I can finally ā immediately and at any time ā use these functions as needed, without worrying about finding files, loading packages, and so on.
Increasing efficiency while reducing costs
Even before the Internet, there were ways to share Wolfram Language code (our first major centralized project was , created for Mathematica in 1991 based on CD-ROM, etc.). Certainly, the proposed approach based on the Wolfram function repository is a more powerful and reliable means of achieving the above tasks.
For over 30 years, our company has diligently worked to maintain the integrity of the Wolfram language structure, which is very important for transforming the Wolfram language into not just a programming language, but a . Thus, the essence of the approach to implementing the Wolfram function repository is to use a unified approach to programming and the development of new functions that are systematically added and integrated into the framework of the language for its potential growth and collaborative evolution.
In the structure of each function's implementation, various computational processes occur. It's important to note that the function must have a clear and uniform appearance and visual readability for the user. In this context, the built-in functions of the Wolfram Language are presented with over 6000 sequential examples of how to correctly program functions (this is our , which include ). This approach ultimately allows making the Wolfram function repository capable of good performance, precisely due to the structural nature of the Wolfram Language with its large number of additional and diverse libraries already embedded in the language. For example, if you have a function that processes images, or , or , as well as or some others ā the language already has their consistent symbolic representation, and thanks to this, your function immediately becomes compatible with other functions in the language.
Creating a repository that truly functions well is an interesting metaprogramming challenge. For instance, an excess of constraints in the program may not allow achieving the required unification and versatility of the algorithm's operation. Likewise, with an insufficient number of functional constraints, it will be impossible to implement a sufficiently correct sequence for the algorithm's execution. Several previous compromise implementations based on these approaches, executed by our company, worked quite stably ā these include: , launched in 2007 and now operating interactively online with over 12,000 user-interactive demonstrations. In the , there are over 600 ready-to-use databases that can be utilized in the Wolfram Language, and is updated with new neural networks almost every week (currently, there are already 118), and they are immediately accessible through the function in the Wolfram Language.
All the examples mentioned above share a fundamental characteristic: the objects and functions assembled within the project exhibit a very high degree of structuring and process distribution. Certainly, the detail of the structure representing a demonstration, a neural network, or something else may vary significantly, but the fundamental structure for any current repository remains unchanged. So, what is your opinion, esteemed user, on the creation of a repository that adds extensions to the Wolfram Language? The Wolfram Language is designed to be extremely flexible, allowing it to be extended and modified in any way. This flexibility is crucial for the rapid development of various large-scale software projects using the Wolfram Language. It's important to note that with the increase in the flexibility of the language, the cost of projects implemented in that language will inevitably rise. This is because the more a user employs such a language, the more dedicated functionality they gain, but it's essential to remember that this approach may also have negative aspects regarding the inability to maintain consistent coherence of the software modules.
In traditional programming languages, there is a common issue with librariesāif you use one library, the code works correctly; however, if you try to use multiple libraries, there is no guarantee that they will interact correctly with each other. Additionally, in traditional programming languagesāunlike a full computing languageāthere are no guaranteed means to ensure consistent built-in representations for any functions or data types, aside from their fundamental structures. But, fundamentally, the problem is even greater than it appears at first glance: if someone is building a large-scale functional vertical, achieving coherence without substantial central programming investmentāwhich we have put into the Wolfram Languageāis impossible. Therefore, it is crucial that all software modules always work correctly together.
Thus, the idea behind the Wolfram function repository is to avoid the aforementioned problem by simply adding extensions to the language in the form of relatively small code elements through separate functions, the development of which as coordinated modules is a simpler task. There are programming features that cannot be conveniently handled with separate functions (and our company plans to release an optimized software algorithm soon to assist in implementing large-scale software packages). However, based on the already built-in functions of the Wolfram Language, there are many programming possibilities that are implemented using separate functions. The idea here is to create a series of new and very useful functions with relatively little programming effort, ensuring enough consistency in the project, while these functions will be well aligned with each other and will also be easily and widely used in the language in the future.
This approach is undoubtedly a compromise. When a more extensive package is implemented, one can envision an entirely new realm of functionality that will be extremely powerful and useful. If there is a need for new functionalities that will fit with everything else, but you are not ready to put in immense effort into project development, this can unfortunately lead to a scaling down of your project. The idea of the Wolfram function repository is to provide functionality that determines the core of the project, allowing powerful features to be added while simplifying the maintenance of good programming consistency.
Assistance in adding custom functions to the function repository
Our specialists have been diligently working to make the contribution to the Wolfram repository functions user-friendly. On the desktop (already in ), you can simply navigate through the tabs of the main menu: File > New > RepositoryItem > Function Repository Item and you will get āā (programmatically within the workspace. You can also use a similar function ā ):
There are two main actions you will need to perform: first, actually write the code for your function, and second, write documentation illustrating how your function should work.
Click the āOpen Sampleā button at the top to see an example of what you need to do:
Essentially, you are trying to create something similar to a built-in function in the Wolfram Language. Except that it may do something much more specific than a built-in function. In this regard, expectations regarding its completeness and reliability will be much lower.
You need to assign a name for your function that adheres to the naming principles of the Wolfram Language. Additionally, you will need to develop documentation for your function, similar to the built-in functions of the language. I will elaborate more on this later. For now, just note that in the row of buttons at the top of the definitions notebook file there is a button , which explains what to do, and a button āTools,ā which provides the tools for formatting the documentation of your function.
When you are sure everything is filled out correctly and you are ready, click the āCheckā button. It is completely normal that you have not figured out all the details yet. Therefore, the āCheckā function will be automatically executed and perform many checks for style and consistency. Often, it will immediately prompt you to confirm and accept corrections (for example: āThis line should end with a colon,ā and it will suggest entering a colon). Sometimes it will ask you to add or change something yourself. We will continually add new features to the automatic functionality of the āCheckā button, but primarily its goal is to ensure that everything you submit to the function repository already meets as many style recommendations as possible.
After launching 'Check', you can use 'Preview'. 'Preview' creates a preview of the documentation page you defined for your function. You can also create a preview for a file created on your computer or for a file stored in the cloud. If you are not satisfied with what you see in the preview for any reason, simply go back, make the necessary corrections, and then click the Preview button again.
Now you are ready to deploy your function to the repository. The Deploy button gives you four action options:
At this stage, it's important that you can submit your function to the Wolfram function repository so that it is available to any user. You can also host your function for a limited number of users. For example, you can create a function hosted locally on your computer, making it available when you are using that specific computer. Alternatively, you can host it in your , making it available to you when you are connected to the cloud. You can also publicly deploy your function through your cloud account. While it won't be in the main Wolfram function repository, you can provide someone with a URL that allows them to access your function from your account. (In the future, we will also support central repositories across our company).
So, let's say you want to actually submit your function to the Wolfram function knowledge base. To do this, you click the 'Submit' button to the repository. So what happens at that moment? Your application immediately enters the queue for review and approval by our dedicated team of curators.
As your application goes through the approval process (which usually takes a few days), you will receive updates on its review status, as well as possibly suggestions for its further use. But as soon as your function is approved, it will be immediately published in the Wolfram function repository and will be available for anyone's use. (And this will be displayed in etc.)
What should be in the repository?
It should be noted that our company has very high standards for completeness, reliability, and overall quality; of the 6000+ functions we have already integrated into the Wolfram language over the past 30+ years, all meet the aforementioned requirements. The goal of the Wolfram function repository is to utilize all the structures and functional capabilities that already exist within the Wolfram Language to add as many lighter functions as possible (i.e., functions with higher performance).
Certainly, functions in the Wolfram function repository must adhere to the development principles of the Wolfram Languageāso they can fully interact with other functions and meet user expectations regarding how functions should work properly. However, functions do not need to have the same level of completeness or reliability.
In the built-in functions of the Wolfram language, we strive to make software functions as general as possible. Nevertheless, there is nothing wrong with a function being included in the Wolfram function repository that simply addresses some very specific but useful case. For example, the function can accept files in one specific format and create mail in one specific way. creates diagrams with only specific colors and labeling, etc.
Another point regarding built-in functions is that our company makes every effort to handle all atypical cases, ensuring correct processing of erroneous inputs and so on. In the function repository, it is entirely normal for there to be a special function that handles the main cases of the task and ignores all others.
It is evident that it is better to have functions that do more and do it better, but optimization for the function repository ā unlike built-in functions of the Wolfram language ā should have more functions tied to a larger number of functions, rather than delving into the implementation processes of each specific function.
Now let's consider an example of testing functions in the repository. Expectations for consistency for such functions are naturally much lower than for built-in functions of the language. This is especially relevant in cases where functions depend on external resources, such as APIs; it is important to constantly conduct consistent tests, which happen automatically within the validation algorithms. In the nb file, you can explicitly specify definitions (in the 'Additional Information' section) and set as many tests as you deem necessary, defined either by input and output strings or by complete symbolic objects of type , as many as you consider necessary. Furthermore, the system continually attempts to turn the examples you provide in the documentation into the testing process (sometimes this can be quite resource-intensive, for example, for a function whose result depends on random numbers or the time of day).
As a result, the function repository will have a range of implementation complexities. Some will consist of just a single line of code, while others may include thousands or tens of thousands of lines, likely utilizing many helper functions. In what cases should a function be added that requires very little code to define? Essentially, if there is a , which users would readily understand upon seeing it as part of the code, then it can already be added. Otherwise, it may be better to just rewrite the code in your program each time you need to use it.
The main purpose of the function repository (as its name suggests) is to introduce new functions into the functionality of the language. If you want to add new data or , use . But what if you want to introduce new types of objects for your computations?
In fact, there are two ways. You may want to introduce a new type of object that will be used in new functions in the function repository. In this case, you can always just write its symbolic representation and use it when inputting or outputting functions in the function repository.
But what if you want to represent an object and then define it through existing functions in the Wolfram Language that should work with it? For that, Wolfram Language has always provided an easy mechanism called . With some restrictions (especially for functions that ), the function repository allows you to simply represent a function and define values for it. (To enhance the expectation of consistency when creating a new important construct fully integrated everywhere in the Wolfram Language, this is typically a very important procedure that cannot be achieved solely by increasing project costs, and this is what our company does within long-term language development projects; this task is not an objective set within the development of the repository).
So, what can be included in the functions code within the function repository? , of course (at least if it does not present for to the functionality of the program itself, as a computational environment) just like any function from the function repository. Additionally, there are other operational possibilities: a function in the function repository can call APIs, either in , or Of course, there are some risks associated with this. Due to the lack of guarantees that the API will not change, the function in the function repository may cease to work. A note on the documentation page (in the 'Requirements' section) highlights such issues for any function that relies not only on the built-in functionality of the Wolfram Language. (Certainly, when it comes to real data, there can be problems even with such functionalityābecause real-world data is constantly changing, and sometimes even its definitions and structure are modified.)
Does all the code for the Wolfram function repository have to be written in Wolfram language? Definitely, the code within the external API does not have to be written in Wolfram language, which does not actually constitute Wolfram language code. In fact, if you find a function in almost any external language or library, you can create a wrapper that allows it to be used in the Wolfram function repository. (Usually, built-in functions should be used for this purpose. or in Wolfram language code.)
So what's the point of doing this? Essentially, it allows you to leverage the entire integrated system of Wolfram Language and its unified set of software capabilities. If you are getting a basic implementation from an external library or language, then you can use the rich symbolic structure of the Wolfram Language to create a user-friendly top-level function that allows users to easily utilize any already implemented functionality. At the very least, this should be feasible in an ideal world where all the components for loading libraries, etc., exist; in this case, they will automatically be resolved using Wolfram Language. (It should be noted that in practice there may be issues with in a specific computer system, and in cloud storage, there may be additional security concerns).
Interestingly, when you first analyze typical external libraries, they often seem too complex to cover with just a few functions. However, in many cases, much of the complexity arises from creating the infrastructure needed for the library and all the supporting functions. In contrast, when using the Wolfram Language, the infrastructure is typically already built into the packages, so there is no need to elaborate on all these supporting functions. You just need to create functions for a few 'top-level' application-oriented functions within the library.
Knowledge Base Ecosystem
If you have written functions that you use regularly, consider submitting them to the Wolfram Function Repository! Even if it doesn't lead to something bigger (language development), it will still be much more convenient for you to use them for personal use. However, it is reasonable to assume that if you find these functions useful, other users might as well.
Naturally, you may find yourself in a situation where you do not have the ability ā or do not wish ā to share your functions, particularly when accessing private information resources. Even in such cases, you can simply deploy functions in your own cloud account, . (If your organization has a , it will soon be able to host its own private function repository that can be managed from your organization and allow forced viewing or not for external users.)
The functions that you submit to the Wolfram Function Repository do not have to be perfect; they just need to be useful. This is somewhat similar to the 'Errors' section in classic Unix documentation ā in the 'Definitions section', there is an 'Author Notes' section where you can describe the limitations, issues, etc., that you are already aware of regarding your function. Additionally, when you submit your function to the repository, you may add notes to your submission that will be read by a dedicated team of curators.
After publishing a function, its page always has two links at the bottom: '" and "If you are attaching a tag (for example, to report bugs), you can check a box indicating that you want your message and contact information to be sent to the function author.
Sometimes there's a need to simply use functions from the Wolfram function repository, such as built-in functions, without looking at their code. However, if you want to 'peek inside,' there is always a 'Notebook' button at the top. Click it, and you'll get your own copy of the original definition notebook that was sent to the function repository. Sometimes you can just use it as an example for your needs. At the same time, you can also develop your own modification of that function. You may want to save the functions you found from the repository on your computer or in your account in your cloud storage, or perhaps you would like to submit them to the function knowledge base, possibly as an improved, enhanced version of the original function.
In the future, we plan to support branching in the Git style for function repositories, but right now we are trying to keep it simpler, and we always have only one commonly accepted version of each function built into the language. Most often (unless developers choose not to maintain the functions they developed and respond to user messages), the original author of the function retains control over updates to it and submits new versions, which are then reviewed and, if they pass the review process, published in the language.
Let's consider the question of how 'versioning' of developed functions works. Right now, when you use a function from the function repository, its definition will be permanently stored on your computer (or in your cloud account if you are using the cloud). If a new version of the function is available, the next time you use it, you will receive a message notifying you about it. And if you want to update the function to a new version, you can do so using the command (The 'Functional BLOB object' actually stores more information about versions, and in the future, we plan to make this more accessible for our users.)
One of the wonderful features of the Wolfram function repository is that any Wolfram Language program can utilize functions from it anywhere. When a program appears in a notebook, it is often convenient to format the functions from the repository as easily readable 'functional binary objects' (possibly with a corresponding set of versions).
You can always refer to any function in the function repository using the textual . This is very convenient if you're writing code or scripts directly for the Wolfram Engine, for example, with (It should be especially noted that the function repository is fully compatible with ).
Initially, a check is performed: does the client device support power via PoE? A voltage of 2.8 to 10 volts is supplied, and the input resistance is determined. If the results obtained are satisfactory for powering via PoE, the power device proceeds to the next stage.
Inside the functions in the Wolfram repository, this is possible using exactly the same database as in (data storage, , etc.), just like all other system resources of Wolfram, ultimately based on the function .
Consider :
Inside you can see some information using the function :
How does the resource function setup work? The simplest case is purely local. Hereās an example that takes a function (in this case just a pure function) and defines it as a resource function for the given session in the program:
After you have made the definition, you can use the resource function:
Note that in this function BLOB object, there is a black icon 
. This means that the BLOB function refers to the resource function in memory defined for the current session. For a resource function that is stored permanently on your computer or in your cloud account, there is a gray icon 
. And for the official resource function in the Wolfram function repository, there is an orange icon. 
.
So, what happens when you use the 'Deploy' menu in the definition notebook? First, it takes all definitions in the notebook and creates a symbolic representation from them. ). (And if you are using a text-based IDE or program, you can also explicitly create )
Local deployment of the function from the repository on your computer is done using the command for the resource object, to save it as in your file system. Deployment in a cloud account is done using the command for the resource object, while public deployment in the cloud ā . In all cases, is also used to register the name of the resource function, so that will work.
If you click the Submit button for the Function Repository, what happens underneath it is invoked on the resource object. (And if you are using a text input interface, you can also invoke directly.)
By default, submission is done under the name associated with your Wolfram ID. But if you submit an application on behalf of a developer group or organization, you can and use it instead as the name for interacting with your views.
After you submit any of your functions to the function knowledge base, it goes into a review queue. If you receive comments in response, they will typically be in the form of a text file with added additional "comment cells". You can always check the status of your submission by going to the . But once your function is approved, you will be notified (via email), and your function will be published in the Wolfram function repository.
Some nuances in operation
At first glance, it might seem that you can just take a definition notebook and literally place it in the function repository; however, there are actually quite a few nuances ā and dealing with them requires quite complex meta-programming, symbolically processing both the code that defines the function and the definition notebook itself. Most of this happens internally, that is, "behind the scenes," but it can have some implications that are worth understanding if you plan to contribute to the function knowledge base.
The first subtle point: When you fill out the 'Definition Notebook', you can simply refer to your function everywhere using a name like MyFunction, which looks like a regular function name in the Wolfram Language, but for the documentation of the function repository, it is replaced by ā this is exactly what users will actually use when working with the function.
The second subtlety: when you create a resource function from the Definition Notebook, all dependencies involved in the function definition must be fixed and explicitly included. However, to ensure that the definitions remain modular, everything needs to be placed in a unique . (Of course, the , are in the function repository.)
Typically, you will never see any traces of the code used to set up this namespace. But if for some reason you call an incomplete symbol within your function, you will see that this symbol resides in the internal context of the function. However, when processing the Definition Notebook, at least, the symbol corresponding to the function itself, as a functional BLOB, not as a raw symbol in the internal context.
The function repository is intended for defining new functions. And these functions can have options. These parameters (for example, or ) often have the ability to be used for built-in functions, as well as those for which there are already built-in symbols. But sometimes a new function may require new options as well. To maintain modularity, these parameters must be symbols defined in a unique internal context (or something like entire resource functions, that is, by themselves). For simplicity, the function repository allows new options to be specified in definitions as strings. And for user convenience, these definitions (provided they used and ) are also processed so that when using functions, the parameters can be specified not only as strings but also as global symbols with the same names.
Most functions simply perform their intended tasks every time they are called, but some functions require initialization before they can operate in a given session ā to address this, there is a section on 'Initialization' within the 'Definition' section.
Functions from the repository can utilize other functions already present in the repository to configure definitions for the function repository, including two (or more) interdependent functions that need to be unfolded in the session so that you can reference them like , after which you can create the desired combinations of these functions as examples and add a new function to the repository based on those already placed earlier.
Development Prospects. What should happen when the repository becomes truly large?
Today we are just launching the Wolfram function repository, but over time we anticipate that its scope and functionality may increase dramatically, and as it evolves, various issues will emerge that we can foresee may arise.
The first issue concerns function names and their uniqueness. The function repository is designed such that, just like the built-in functions in the Wolfram Language, you can reference any given function by simply stating its name. However, this inevitably means that function names must be globally unique throughout the repository, so, for instance, there can only be one .
At first glance, this may seem like a significant problem, but it's important to understand that it is essentially the same issue as that of internet domains or social media handles. The fact is that the system simply needs to have a registrar ā and this is one of the roles our company will fulfill for the Wolfram function knowledge base. (For private versions of the repository, their registrars can be administrators.) Of course, an internet domain can be registered without anything on it, but in the function repository, a function name can only be registered when there is a valid function definition.
As part of our role in managing the knowledge base of Wolfram functions, we ensure that the name chosen for a function is logical in terms of the function's definition, and that it complies with the naming conventions of the Wolfram Language. We have over 30 years of experience in naming built-in functions in the Wolfram Language, and our curation team will apply this experience to the function repository as well. There are certainly always exceptions. For example, it might seem preferable to have a short name for some function, but it is better to 'protect' with a longer, more specific name, as there is less chance that someone will want to create a similar function name in the future.
(It is worth noting here that simply adding any participant tag to eliminate ambiguity of functions will not have the desired effect. Because, if it is not insisted that a tag is always assigned, a default tag will need to be defined for any given function and also author tags will need to be highlighted, which again requires global coordination.)
As the volume of the Wolfram function knowledge base grows, one of the issues that will surely arise is the discoverability of functions, for which the system provides a (and definition files can include keywords, etc.). For built-in functions in the Wolfram Language, the documentation includes all kinds of cross-references that help to 'promote' functions. Functions in the function repository can refer to built-in functions. But what about the other way around? For this, we plan to experiment with various schemes to present repository functions on the documentation pages for built-in functions.
For built-in functions in the Wolfram Language, there is a so-called level of discoverability provided by , which provide organized lists of functions related to specific areas. It is always difficult to properly balance reference pages, and as the Wolfram language grows, the reference pages often need to be completely reorganized. Itās relatively easy to place functions from the repository into broad categories and even consistently break these categories down, but it is much more valuable to have properly organized reference pages for the language. It is still unclear how best to create them for the entire knowledge base of functions. For example, in the functions repository, anyone can host a web page containing their 'selections' from the repository:
The Wolfram functions repository is set up as a permanent storage of functions, where any function within it will always work. Certainly, new versions of functions may appear, and we expect that some functions will inevitably become obsolete over time. Functions will operate if used in programs, but their documentation pages will point to newer, more advanced functions.
The Wolfram functions repository is designed for quickly accessing new functions and exploring new ways to utilize the Wolfram language. With a high degree of optimism, we hope that some of what has been explored in the functions repository will ultimately make sense to become built-in parts of the core Wolfram Language. Over the last decade, we have had a similar set of . One of the lessons learned from this experience is that achieving the standards of quality and consistency that we emphasize in everything built into the Wolfram language requires a lot of work, which is often much more challenging than the initial efforts to implement the idea. But even so, a function in the knowledge base of functions can serve as a very useful proof of concept for a future function that may ultimately be built into the Wolfram language.
The key point here is that the function repository is something that is available to every user for immediate use. While the built-in functions of the language might be significantly better and more efficient, the function repository allows users quick access to all new features. Importantly, this concept enables anyone to add their own new functions.
In the past, this idea would not have worked as well in the history of the Wolfram language, but at this stage, so much effort has been put into the language and there is such a deep understanding of the design principles that it now seems quite feasible for a large community of users to add functions that maintain the project's coherence and make them useful for a wide range of users.
There is an incredible spirit of talent within the Wolfram Language community. (Of course, this community includes many leading specialists in research and development across various fields.) I hope that the Wolfram Function Repository will provide an effective platform for unleashing and spreading this spirit of talent. Only together can we create something that significantly expands the areas where the Wolfram language's computational paradigm can be applied.
Over the past 30 years, we have come a long way with the Wolfram language. Now, together, let's go even further. I strongly encourage all respected users of the Wolfram language worldwide to use this functional repository as a platform, as well as a new software project like Free Wolfram Engine for developers.
Source: habr.com
