Skip to content

The Arif Programming Language - without "end" keyword for scope, Just In Time Compilation (Built-In Auto Inclusive Templates) with Polymorphism Together with Dynamic Memory Management (Pointers) and Rust-like segmentation fault Analysis in compile time & TCO If ALLAH gives permission https://github.com/JuliaLang/julia/issues/53163#event-11690734659

License

Notifications You must be signed in to change notification settings

TANRININresulu/Arif

 
 

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

Documentation
Continuous integration
Code coverage Coverage Status

If ALLAH gives permission arif will have async (with promises and intrinsic auto model-view-controller design paradigm convertion built-in compiler better than in svelte without bloating syntax like in ruins in svelte5* in that) mode option together with Document-Object-Model class for being able to run also as a html and css driver reactive www(666) surfing language

  • If ALLAH gives permission for acheiving reactivity in asynchronous mode without bloating syntax like ruins(runes) in svelte 5, arif compiler should faciliate recursive search tree functions for detecting caller and callee type variable tokens from semantics of given elegant syntactic arif program text InshALLAH !

IF ALLAH gives permission tail call optimization is easy to grasp concept if you read this short article: https://medium.com/@JavaScript-World/javascript-recursion-and-tail-call-optimization-944be86bb3bb

If ALLAH gives permission HIS servant i will use recursive search tree algorithm on adress pointer edge-node graph for deallocation decisions of garbage collector of arif language in compile-time with an optional compilation flag for ease-of-use in terms of memory management together with smart-pointer support see a discussion here: https://gist.github.com/Manishearth/70856e2f01e18935681c#

https://doc.rust-lang.org/book/ch15-00-smart-pointers.html

https://en.wikipedia.org/wiki/Smart_pointer

If ALLAH gives permission HIS servant i will add multi-paradigm functional-declerative-imperative language syntax support by exampling from lisp(owl-lisp) syntax - prolog with unknown aware logic gates with built-in exception handling mechanism for unknown valued results - julia like auto intrinsic typed explicit typeless syntax with smart pointers of rust and support for cross mixed syntax support between those paradigms by model of abstract syntax tree that encompassing all elements of functional-declerative-imperative paradigm abstractions by layers by of layers...

If ALLAH gives permission HIS Servant i will make arif language more encompasser in terms of language paradigms than haskell: https://stackoverflow.com/a/43426291/2059149

The Julia Language

Julia is a high-level, high-performance dynamic language for technical computing. The main homepage for Julia can be found at julialang.org. This is the GitHub repository of Julia source code, including instructions for compiling and installing Julia, below.

Resources

New developers may find the notes in CONTRIBUTING helpful to start contributing to the Julia codebase.

External Resources

Binary Installation

If you would rather not compile the latest Julia from source, platform-specific tarballs with pre-compiled binaries are also available for download. The downloads page also provides details on the different tiers of support for OS and platform combinations.

If everything works correctly, you will see a Julia banner and an interactive prompt into which you can enter expressions for evaluation. You can read about getting started in the manual.

Note: Although some OS package managers provide Julia, such installations are neither maintained nor endorsed by the Julia project. They may be outdated, broken and/or unmaintained. We recommend you use the official Julia binaries instead.

Building Julia

First, make sure you have all the required dependencies installed. Then, acquire the source code by cloning the git repository:

git clone https://github.com/JuliaLang/julia.git

and then use the command prompt to change into the resulting julia directory. By default, you will be building the latest unstable version of Julia. However, most users should use the most recent stable version of Julia. You can get this version by running:

git checkout v1.10.0

To build the julia executable, run make from within the julia directory.

Building Julia requires 2GiB of disk space and approximately 4GiB of virtual memory.

Note: The build process will fail badly if any of the build directory's parent directories have spaces or other shell meta-characters such as $ or : in their names (this is due to a limitation in GNU make).

Once it is built, you can run the julia executable. From within the julia directory, run

./julia

Your first test of Julia determines whether your build is working properly. From the julia directory, type make testall. You should see output that lists a series of running tests; if they complete without error, you should be in good shape to start using Julia.

You can read about getting started in the manual.

Detailed build instructions, should they be necessary, are included in the build documentation.

Uninstalling Julia

By default, Julia does not install anything outside the directory it was cloned into and ~/.julia. Julia and the vast majority of Julia packages can be completely uninstalled by deleting these two directories.

Source Code Organization

The Julia source code is organized as follows:

Directory Contents
base/ source code for the Base module (part of Julia's standard library)
cli/ source for the command line interface/REPL
contrib/ miscellaneous scripts
deps/ external dependencies
doc/src/ source for the user manual
etc/ contains startup.jl
src/ source for Julia language core
stdlib/ source code for other standard library packages
test/ test suites

Terminal, Editors and IDEs

The Julia REPL is quite powerful. See the section in the manual on the Julia REPL for more details.

On Windows, we highly recommend running Julia in a modern terminal, such as Windows Terminal from the Microsoft Store.

Support for editing Julia is available for many widely used editors: Emacs, Vim, Sublime Text, and many others.

For users who prefer IDEs, we recommend using VS Code with the julia-vscode plugin.
For notebook users, Jupyter notebook support is available through the IJulia package, and the Pluto.jl package provides Pluto notebooks.

About

The Arif Programming Language - without "end" keyword for scope, Just In Time Compilation (Built-In Auto Inclusive Templates) with Polymorphism Together with Dynamic Memory Management (Pointers) and Rust-like segmentation fault Analysis in compile time & TCO If ALLAH gives permission https://github.com/JuliaLang/julia/issues/53163#event-11690734659

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published

Languages

  • Julia 67.8%
  • C 16.4%
  • C++ 10.4%
  • Scheme 2.6%
  • LLVM 1.1%
  • Makefile 1.0%
  • Other 0.7%