Topical | Project site in English

Scientific programming languages

Sat, 28 May 2022 18:30:00 +0000

Scientific programming is a field of programming that relies on the use of computers for research purposes. His tasks are often very different from industrial programming – while there is often a focus on code readability and maintainability, here the speed with which the program design can be iterated is more important.

Because of this feature, many programming languages are poorly suited for scientific programming. For example, Rust, with its focus on the formal correctness of all memory usages, often slows down the developer, and Java and other strictly object-oriented languages require a more fundamental architecture than is often possible in scientific programming.

One of the languages that is very often used in scientific programming is Python. It is very popular, has an easy-to-learn syntax, allows many different approaches to solving architectural problems, and also integrates into libraries written in C and C ++, which are faster and implement the most complex parts of the algorithms. This makes the Python language convenient for gluing different data together and processing it in different ways, which is exactly what is useful in scientific programming.

Other languages that are often used for working with data – R, Julia, and Ada – have simple syntax, a rich type system, and links to C/C++ code, and all these features also make them useful in scientific programming.

Among other options, functional languages like Haskell, F#, and Clojure allow algorithms to be described in a more declarative style – don’t say what calculations are to be done, but instead state the formulas that need to be calculated in the end.

Rarer programming paradigms like logic programming – as implemented in Prolog and Erlang, for example – are rarely used in industrial applications, but in scientific programming they are often useful. In logic programming, the programmer specifies statements about terms – for example, “If something is a cat, then it is an animal”, “If something is an animal, then it is alive or dead”, “If something is alive, then it is not dead”, “There is something called Barsik”, “If something is called Barsik, then it is a cat” and “If something is called Barsik, then it is not dead”. After that, you can ask questions like “What things are animals?”, “What things are alive and dead at the same time?”, “Is Barsik a cat and alive?” etc. This kind of reasoning is often called logical propositions, and most programs are difficult to translate into a form that consists entirely of logical propositions. However, in scientific programming, there are often questions that can be framed as logical statements, and such languages help with this.

Thus, scientific programming has tasks that often differ from industrial tasks, so the set of languages and paradigms that find application in scientific programming is very wide.

Working with bibliographies

Fri, 20 May 2022 18:30:00 +0000

A bibliography is a set of records about the literature that was used in the preparation of a document. It serves as a way to cite past work on the topic and to provide links to sources for further information.

Usually the bibliography is printed at the end of the document, and sometimes there are references to certain entries from the text of the document. For example, if I wanted to say something that can be read about in a certain book, I would write something like:

On systems that support this, the name of the TeX markup language must be written in full capital letters, but the letter E should be shifted down from the baseline (see [TEXBOOK]).

After that, in the bibliography part, I would write:

[TEXBOOK] D.E. Knuth, D. Knuth, D. Bibby, and American Mathematical Society. The TeXbook. Computers & typesetting. Addison-Wesley, 1986.

With this information, the reader of my document can go to the library to find this book and read the part I am talking about in the text.

Such records can be written by hand, but this quickly becomes inconvenient as the number of sources increases. Therefore, scientific writing systems like TeX have mechanisms for managing bibliographies.

For example, BibTeX uses a file containing records of the sources used. The same book will be written in it as follows:

 @book{knuth1986texbook,
  title={The TeXbook},
  author={Knuth, D.E. and Knuth, D. and Bibby, D. and American Mathematical Society},
  isbn={9780201134476},
  lccn={85030845},
  series={Computers\& typesetting},
  url={https://books.google.ru/books?id=zqgQAQAAMAAJ},
  year={1986},
  publisher={Addison-Wesley}
}

This machine-readable format stores information that will then be included in the entry in the bibliography. However, you may notice that not all fields were included in the record. This is because the bibliography entry template I used does not use this information. If a document is published in a journal or other publication, this publication will certainly have its own style of bibliography; if you select this style in the BibTeX settings, the record will look different.

BibTeX is one of the bibliography management systems. There are others like EndNote, Mendeley, RefWorks, Zotero, etc. They differ in their interface, supported citation formats, supported data attachments, etc., but most have BibTeX export options. Using such systems, it is possible to structure the set of literature used in the text, which makes it possible to write scientific articles with the correct references quickly and conveniently.

Markup languages, LaTeX

Sat, 14 May 2022 18:30:00 +0000

A markup language is a way of writing text in a format that is suitable for machine processing and often contains, in addition to the text, instructions for displaying that text. There are many different markup languages that work well for different tasks.

We will consider the LaTeX language, which is most often used for writing scientific papers. It is an extension of the TeX layout language, invented by Donald Knuth in 1978. Backslashes are used to call commands, and curly braces are used to specify arguments:

This text is \emph{in italics}.
This text is in \textbf{bold}.
\begin{large}This text is larger than usual.\end{large}
\begin{Large}This text is even larger than usual.\end{Large}
\begin{LARGE}This text is STILL larger than usual.\end{LARGE}
\begin{huge}This text is huge.\end{huge}
\begin{Huge}This text is Huge.\end{Huge}

One of the most famous features of the LaTeX language is the ability to enter complex mathematical formulas. For example, this code:

\begin{equation}
\Delta M_i^{-1} = - \alpha \sum_{n=1}^N D_i \left[ n \right] \left[ \sum_{j \in C \left[ i \right]}^{} F_{ji} \left[ n -1 \right] + Fext_i \left[ n^{-1} \right] \right]
\end{equation}

…displayed as follows:

(This expression is the title of one of Aphex Twin’s tracks.)

Because of this capability, LaTeX remains the gold standard for formatting mathematical texts, and it is not uncommon for other document authoring environments (such as Microsoft Word) to copy some of the syntax. Some programs even use the LaTeX engine as part of their work – for example, Pandoc uses it to convert documents to PDF, and Manim’s programmable animation library uses it to display mathematical formulas in SVG format.

LaTeX also has a wide standard library that allows you to use it to display pictures, graphs, code blocks, and more. Thus, LaTeX is one of the most important markup languages for scientific documents, and it is worth knowing for anyone who plans to write documents with mathematical formulas or other complex display elements.

Version control and Git

Sat, 07 May 2022 18:30:00 +0000

Modification Control Systems (VCS) allow you to track changes in your code, look through history to look for specific changes, and coordinate work on the same code base between multiple developers. Today we will look at how one of the most popular VCS, Git, works.

Story

Git was developed in 2005 by Linus Torvalds to help develop the Linux kernel. Shortly before this, there was a scandal with Bitkeeper, a proprietary version control system that was used by many developers, but was no longer available for free after the copyright holder found out that it was reverse-engineered to create SourcePuller.

The goals of the project were: to make a distributed VCS that could support a procedure similar to Bitkeeper, but was also fast (no more than three seconds to apply a patch) and had strong protection against errors and unintentional modifications.

Principles

Git’s primitive data structures do not necessarily implement VCS. There are two places where information is stored – a dynamic index that describes the state of the working tree, and an immutable object database. The latter stores the following five types of objects:

BLOB – the content of the file, denoted by its hash. Each BLOB is a separate version of a file.
a tree is analogous to a directory, which has links to sub-trees and BLOBs to represent one version of the working tree.
A commit is a history element pointing to the tree it describes and one or more previous commits.
tag - an object that has a link to some other object and some additional information about this object. Most commonly used to add digital signatures to commits.
packfile – a file containing several other objects in a compressed format for compactness.

Because of this design, each repository contains the entire history and can be viewed locally. This is what makes Git distributed VCS.

The commit history is structured as a singly-linked tree, and because the identifiers are based on a cryptographic hash of the content, this can also be thought of as a blockchain instance. Each commit can have a parent, the commit that the changes are based on. With the help of them you can go back to the history of changes. Since each commit is identified by its hash, any change in history requires the hash of each object to be recalculated further, which provides cryptographic protection against changes.

In addition to this, Git maintains a linkbase. Head objects point to the latest commit on a branch, they call the branch, and are in fact branches. One special head, called HEAD, points to the current branch from which the comparison to the working tree is being made. There are also tags, which, like head, indicate commits, but unlike them do not move, and can instead be used to mark important points in the project’s history.

History keeping process

Git does not dictate how a project’s history should be maintained. One option that is supposed to be used in the OS course involves short-lived branches within which work is done to implement a new feature, and then this branch is merged into the main tree when the feature is completed. Other options include long-lived branches ranked by code stability, or branches assigned to specific team members.

Different methods have their pros and cons, which are more or less obvious depending on the type of project and the development methodology that the team uses.

Conclusions

Git is one of the most popular VCS, and for good reason. It was written to solve problems with existing SLEs, and it was able to solve them much more effectively than any other solution at the time.

One of the factors behind its popularity has been the rise of Git hosting services such as GitHub, GitLab, and BitBucket. These services allow you to publish a Git repository and make it available from the web, and their convenience has led many users to now associate Git with GitHub.

With such popularity, ease of casual use, and yet depth of functionality for advanced use, Git is now a must for any kind of code development. That is why in the OS course we learn the basics of using Git.