A+
A+ is an array-based programming language made by Arthur Whitney. “A” was the original language, but later A+ was created to be a more powerful and efficient alternative. The language includes many features, such as an X11-based graphics tool kit that enhances IPC functionality in A+. It’s also a higher-level language with great amounts of primitive functions to easily manipulate arrays. The language is a dialect of APL and includes a graphical user interface and inter-process communication while programming. Not to mention, you can utilize reactive programming in A+ by changing one piece of data to trigger others. Programming in A+ allows users to set up dependencies through variables so whole systems can change. This feature allows the programmer to have powerful tools like spreadsheets and complex calculators. However, a downside while coding can be having to change fonts for the various hieroglyphics used in the APL.
History
The history of A+ branches from “A” and was first created in 1988. Though this seems like a long while back, it was used very powerfully in various ways back then. People invested in APL applications and really wanted to manipulate data sets like arrays, which A+ specializes in. As users were moving towards distributed systems, they were in need of a powerful APL language. Shortly after, A+ has named the best source of implementation to run on SunOS, the main system used then. High performance and capacity were the main characteristics needed going forward programming in A+. Arthur’s peers at Morgan Stanley made sure this happened and implemented graphical user interfaces and features like utility support. Over the years, A+ succeeded with its growing community and referred its “+” to an electric graphical user interface. Later, an official A+ developmental group was created in 1992.
Platforms
Popular platforms used to support A+ were systems like SunOS. However, back then there were not as many platforms around in the first place. A+ was basically centered around SunOS and didn’t really specialize in any other programming systems. This makes sense because the language was one of the only APL languages around. At the same time, developers were all on board because it was the first of its kind. Although, since A+ was also highly centered around financial applications, it could also be used on Linux. More specifically, A+ ran on a lot of Unix variants that promoted financial tools like spreadsheets. Right now, there are no current platforms that support the features found in A+. However, there are old available systems that can potentially run A+ code and still make use of its functionalities.
Benefits and downsides
In previous years, there were many new benefits that were exclusive to A+. Although, nowadays it’s quite the opposite. One of the benefits of using A+ was its different programming style approach. It used lexical, rather than dynamic binding that helped solve older problems of APL, while still keeping things safe. In addition, the current APL system was outdated and had its own issues. It lacked control structures and had trouble dealing with functions, but this could easily be done through A+. Another benefit, however, was the ability of A+ to efficiently use code. One line of code in A+ can result in a lot more lines in a language like C++. It is effective and efficient, but developers nowadays don’t take it over the bigger named ones.
Nowadays the trend of A+ has been going down. This is an indicator of a downside since it’s probably not useful if many developers don’t use it anymore. To add, a downside when it was used back then was that it was only on SunOS systems. Though that was one of the most popular systems, people who didn’t have access were limited.
Many developers have noted that there are also no real materials to learn A+. The references are very limited and barely give you examples of syntax or structures. It seems as if the language died out and no one ever thought of updating or revising its documentation. For this reason, it is not really used too much in the industry nowadays. Because of this, having this skillset doesn’t really equip you with the knowledge you can use on your own. The last known update I found was in the late 2000s. Since then, there hasn’t seemed to be any other updates in A+.
History
Examples of code
A+ has many different versatile functions and syntax used in its code. However, just looking at if statements and loops it is quite similar to python and other programming languages. This is especially true with the syntax of A+.
The structure of an if statement in A+ starts with the word If. After that, an expression can be written inside parentheses. Lastly, it is followed by another expression or an expression block. As you can tell, this sounds very similar to most other programming language’s syntax. If you want to add an else statement you can do that as well. All that is needed is to add the word else on the same line after the parenthesis.
Going onto loops, in A+ it is much like python and other high-level languages. The syntax is pretty similar for a loop and an if statement since it is intuitive. Though there may be some characters that are confusing, loops can be written pretty straightforwardly in A+. A while loop for example starts off with while. Next, an expression in parenthesis is written followed by another expression or expression group. In the case where an expression is entered in the parenthesis by itself, the code will return null. Though these examples seem simple, it may take longer to grasp the syntax of complexities like functions in A+.
An example of an if statement in A+ can be written as:
If (a=b) {
a = 5;
}
sys.exit 0
An example of a while loop statement in A+ can be written as:
while(a<b) {
a = (a + b)/b;
}
sys.exit 0
Trends
A+ hasn’t been trending so much over the recent decades. Nowadays, languages like C++ and Python easily replace it by having its functionality, and more. Developers have been shying away for A+ because of this and its popularity took a significant plummet. This also explains the reason why there are no current supported platforms for A+. Also, nowadays object-oriented programming is becoming more popular than array-based programming. Object-oriented programming is less advantageous in an abstract sense but more advantageous with variables and functions. It is used by many developers today and entails manageability and a lot of similar array-based programming features. In fact, you can even implement array-based programming within object-oriented programming.
Others: Differences with other languages
In more recent years, A+ has seen more of a decline but is still deemed as “efficient.” Some unique aspects of the language show that and why it was so effective in its earlier years. For example, there are many special characters within the programming language that makes it one of a kind. Such as a “«” symbol to signify multiplication and a “ß” to symbolize division. Usually, we see the “*” and “/” symbols to represent these operations but this goes to show the differences of A+ references. In A+, there are two different names that represent symbols. These are called Dyadic and Monadic names. For example, the previous multiplication and division symbols listed above have different Dyadic and Monadic names. In Dyadic terms, “«” is multiplication, but in Monadic terms it means sign. And for the “/” symbol it means divide for its Dyadic name, but reciprocal for its Monadic one.
The syntax of A+ symbols is just one example of the difference between A+ and other programming languages. Some other key differences are the variance in variables, functions, and commands in the language. In A+, these functions start off with an underscore and usually an abbreviation of the task. This can be seen with “Changing Directory” or “Debug.” The way these functions are written are ”_cd” and “_dbg.” Overall, this unique style of code shows how A+ was different than other languages, yet just as effective.
Lastly, another example of a difference of A+ compared to other languages is files. You can do more with files in A+ by mapping simple arrays, changing directories, adding new items, etc. For instance, the Form of Name can be written as “*.” which uses data functions (ex, util.+). Mappable arrays can also be used and are written as “*.m” which can help increase simplicity. Say you have a file with prices, you can make a mappable array by writing “prices.m” to create a new list. For printing files in A+, the “$| test lpr” command is used to pipe the file “test” to lpr command. To get around, users can also utilize the “$cd” command. This allows users to change the Unix directory of files, while still maintaining the simplicity and stylistic elements. Ultimately these variances serve as the main reasons why programming is unique, simple, and efficient in A+.
Others: Applications
Some applications that are found in A+ are its financial abilities and manipulations within arrays. Programming in A+ is easy with a graphical user interface and reactive programming. Users can take advantage of this and change a piece of code that’ll create a reaction for other changes. This will induce spreadsheet-like programming and allow the developer to have full control over their code. Financial places can really take advantage of this but really anywhere systems like spreadsheets are used can benefit. Applications are endless for A+ if used properly and its unique style enables programming to be efficient and effective. If you want to also change files like directories A+ makes it simple as can be. As mentioned above, you can use commands like “_cd” to change a directory within a file. This means, in industry users can have ease of implementation and utilization.
Takeaway on A+
A+ is still a powerful and useful tool that can be modified and used by developers today. The sheer power of its reactive programming alone can be the reason for more implementation. But as we know, it can do even more than that. The manipulation of complex arrays, its lexical programming approach, and authenticity are only some examples. This list goes on, and frankly, if it didn’t get replaced, many places would still be utilizing its properties. Overall, A+ was a great solution to a big problem of APL implementation running on SunOS. One thing’s for sure though, A+ is still considered more efficient in some circumstances compared to other languages. As mentioned, one line can outpower potentially 50 lines in other low-level languages. If not for A+, we may not have been able to innovate and progress to where we are today.
