Forem: Olaf Minkowicz

The Misconception of Functional Programming in JavaScript

Olaf Minkowicz — Fri, 03 Jan 2020 02:51:59 +0000

The term functional programming gets thrown about when developers talk about it in the context of JavaScript and it seems to a term that is very much understood by junior developers. This article is a breakdown of the term itself, how it’s used in JavaScript and how it’s being applied in popular frameworks such as React.

Functional programming, the term has been around since the 1930s and has its origins in lambda calculus. That specific term, “functional programming”, refers to a programming paradigm (classification of programming languages regarding their features and architecture) that refers to the consistent evaluation of mathematical computational models and functions that avoid changing state and mutable data.

Now while JavaScript can be classified as a functional programming language and has the capabilities to be written in that specific structure it supports multiple different programming paradigms and is classified under several. With the introduction of classes in ECMAScript 2015 more individuals start debating overusing object-oriented programming vs functional programming. Now while we have the syntactic sugar of classes it does NOT introduce any new object-oriented inheritance models to JavaScript. Classes are just a thin layer of paint on top of JavaScript’s prototype inheritance.

In React you can have functional components and class components. Before the introduction of React hooks, only class components had state and functional (stateless) components that could be classified as being written in a functional programming model. Now with hooks, you can use state in functional components and it’s up in the air if you could consider them written in a functional programming architecture now that state is being used in them. The whole point of the functional programming paradigm is avoiding changing state while evaluating functions, with the addition of hooks letting you change state it is void of that.

Passing parameters with modifiers in C#

Olaf Minkowicz — Wed, 02 Oct 2019 23:42:14 +0000

A parameter is a variable that holds some sort of value that is passed as information into a function, procedure or method. Function, procedure, and method can be used as synonymous terms as they are named differently in different computer languages. (Guidelines, 2019)

If you do not want to change the value of the arguments you are passing into a method you will “pass by value”. This way the initial arguments passed into the method as it’s parameters will not have their values changed even if they are modified in the body of the method. If you want to change the value of the arguments you are passing into your method and have them persist within your working environment you will then have them “pass by reference”.

There are several ways you can pass parameters in a method.

Parameter Modifier	Passed By	Explicitly Assigned Before	Variables Changed Within
None	Value	Going In	Yes
ref	Reference	Going out	Yes
out	Reference	Going out	Yes
in	Reference	Going in	No
params	Reference	Going out	Yes

When we say that the parameter is passed by the value we mean that a copy of that value is passed to the method. You can “pass by value” a value data type or a reference data type parameter and that parameter being passed will be an independent reference to the original value or reference type. (Albahari & Albahari, 2010) The copy that is being passed holds a different memory location than the original value.

It should be also noted that a parameter can be passed by reference or by value regardless of the parameter type, being value or reference. (Albahari & Albahari, 2006)

Don’t confuse passing by reference or passing by value with reference or value types. Below is a quick overview guide for value types and reference types. It is not a complete reference to all value and reference types but an overview to give a reminder and give context to the keywords we are using. (Wenzel, et al., 2019)

Value Type	Reference Type
bool	Class
byte	Interface
char	Delegate
decimal	Dymanic
double	Object
enum	Array

Passing a value into a method with no modifier

By default, in C# passing parameters through methods is done by value, which is the most common way of passing parameters in methods. (Albahari & Albahari, 2010)

Default modifier

The initial value that we pass into the method will never have its original value changed, as shown below in the snippet of code.

static void Main(string[] args)
{
    int items = 8; //items is asisgned 8
    itemsInStock(items);
    Console.WriteLine("Items to add to stock : {0}", items);
    //the variable items does not have its value changed
    Console.ReadLine();
}

static void itemsInStock(int items)
{
    int totalStock = 50;
    items = totalStock + items;
    Console.WriteLine("new items available in Stock : {0}", items);
    //items has its variable changed within the scope
}

Your output will be:

New items available in Stock: 58
Items to add to stock : 8

Passing values into a method with modifiers:

When you pass a parameter by reference it allows you to change the value of that passed parameter into the method while having it persist in the environment.

Reference parameters: ref modifier

When using the ref modifier, it specifies that the parameter being passed into the method is being passed by reference and not by value. This means that the values passed in as a parameter with the ref modifier have the same corresponding memory location and their values, if changed, will persist in the scope outside of the method.

Before passing an argument with the ref modifier you must explicitly initialize it. The ref modifier is required both in writing and calling the method. (Data, 2001)

static void Main(string[] args)
{
    int items = 8; //items is asisgned 8
    itemsInStock(ref items);
    Console.WriteLine("Items to add to stock : {0}", items);
    //the variable items has its value changed
    Console.ReadLine();
}

static void itemsInStock(ref int items)
{
    int totalStock = 50;
    items = totalStock + items;
    Console.WriteLine("new items available in Stock : {0}", items);
    //items has its variable changed within the scope
}

Your output will be:

New items available in Stock: 58
Items to add to stock : 58

Output parameter: out modifier

An out modifier is like a ref modifier in that it does not create a new storage location in memory for the passed argument. It is different from the ref modifier because you do not need to initialize the variable before it is passed. It also needs to be declared in the method definition and when calling the method.

The main purpose of using the out modifier is to be used when you have a need to have multiple return values. (Data, 2001)

    static void Main(string[] args)
    {
        int items = 8; //items is assigned 8
        int apple, orange;
        itemsInStock(items, out apple, out orange);
        Console.WriteLine("Items to add to stock : {0}", items);
        //the variable items has its value changed

    Console.ReadLine();
    }

    static void itemsInStock(int items, out int apple, out int orange)
    {
        apple = 5;
        orange = 10;
        int totalStock = 50;
        items = totalStock + items;
        Console.WriteLine("New items available in Stock : {0}", items);
        //items has its variable changed within the scope
    }

Your output will be:

New items available in Stock: 58
Items to add to stock : 8
We have 5 apples and 10 oranges.

In parameters: in modifier

If you want to pass a parameter by reference read-only into a method with the intent of not copying the value but also not wanting to change the value you will need to use the in modifier. The only reason for using the in modifier would be for use in high-performance scenarios because passing an argument is constant and doesn’t depend on the size of the value. (Tepliakov, 2018)

Parameter array: params modifier

A parameter declared with a params modifier takes any variable number of arguments separated by commas or an array. You may also choose to specific no arguments which will result in the length of the params parameter list as 0. (Data, 2001) Its primary use is as a shorthand to input as many parameters you would like with no need to specify the use of an array.

Conclusion

A parameter passed by a ref modifier corresponds to the actual memory location of that value and if changed will persist outside the method scope/
The out modifier should be used when you need to have multiple return values.
The in modifier references the memory location of the parameter like the ref modifier but it will not allow the arguments passed to be changed.
The params modifier takes any number of parameters passed onto it separated by commas, an array or none. It is useful as shorthand and when you do not know the specificity of an array length.

References

Albahari, J., & Albahari, B. (2006). C# 4.0 IN A NUTSHELL The Definitive Reference. Sebastopol: O'Reilly Media, Inc.

Albahari, J., & Albahari, B. (2010). C# 4.0 Pocket Reference. Sebastopol, CA, USA: O'Reilly Media. Retrieved October 1, 2019

Data, L. o.-i.-P. (2001). Microsoft C# Language Specifications. Redmond: Microsoft Press.

Guidelines, V. V. (2019, October 1). Definitions of Words with Special Meanings. Retrieved from U.S. Election Assistance Commission: Online

Tepliakov, S. (2018, March 7). The ‘in’-modifier and the readonly structs in C#. Retrieved from Microsoft Premier Developer: Online

Wenzel, M., Wagner, B., A, A., Latham, L., Schonning, N., Hoffman, M., & B, M. (2019, October 1). Reference types (C# Reference). Retrieved from Microsoft Documentation : Online

ECMA Who? ECMA What? You should get that checked out!

Olaf Minkowicz — Fri, 27 Sep 2019 13:49:33 +0000

What is ECMAScript, ECMA-262, and JavaScript?

ECMAScript is the standardized scripting-language procedures and specifications by the (European Computer Manufacturers Association) ECMA International. The best-known implementation of these scripting-language standards and procedures is JavaScript, JScript, and ActionScript.

JavaScript is the scripting language, which was created within ten days, developed by Brendan Eich for Netscape. It was originally named Mocha, then renamed LiveScript and finally to JavaScript. The prefix Java makes it seem like it has some type of relation to Java the interpreted programming language, but it does not. JavaScript and Java are two different languages.[1]

JScript is Microsoft’s implementation of ECMAScript but could be described more efficiently as a dialect of ECMAScript.[2]

ActionScript is another dialect of ECMAScript that was originally developed by Macromedia Inc. for Macromedia Flash before it got acquired by Adobe and became Adobe Flash; later changed to be known as Adobe Animate.[3]

One of the most popular supersets of JavaScript would be Microsoft own open-source language TypeScript. Typescript transcompiles to JavaScript. What that means is that it takes its current source code and produces the source code in a different language like in this instance JavaScript. Why use it then? Well, as its name states, it has static typing as well as other features. Typescript has a more object-oriented programming approach compared to JavaScript.

There’s always confusion between ECMAScript, JavaScript, and the technical standard language specification ECMA-262. This snippet from an interview with InfoWorld and Brendan Eich should give some insight to it:

InfoWorld: What’s the difference between ECMAScript and JavaScript, or are they one and the same?
Eich: ECMAScript is the standards name for the language. Its number is ECMA-262 and it’s a name that the standards body came up with because they couldn’t get anybody to donate a trademark that was agreeable to all parties. So there’s an issue with marketing the programming languages.
JavaScript would have been the ideal name because that’s what everyone called it and that’s what the books call it. Microsoft couldn’t get a license from Sun so they called their implementation JScript. So ECMA wanted to call it something and they couldn’t get anybody to donate or they couldn’t get everybody to agree to a donation of the trademark, so they ended up inventing ECMAScript, which sounds a little like a skin disease. Nobody really wants it.
And so you have this funny [situation] where you have a standard with a funny name or number and then various implementations that have trade names. And the trade names don’t have a huge value, except JavaScript is the common name. It’s in all the books, it’s what people say. [4]

References

1 D. Crockford, "JavaScript: The World's Most Misunderstood Programming Language," 2001. [Online].

2 "JScript (ECMAScript3)," 23 October 2011. [Online].

3 "Where is Flash Professional?," 8 May 2019. [Online].

4 P. Krill, "JavaScript creator ponders past, future," InfoWorld, 23 June 2008. [Online].