#functional-programming

#functional-programming

NestJS Nest is a framework for building efficient, scalable Node.js server-side applications.It uses modern JavaScript, is built with TypeScript (preserves compatibility with pure JavaScript) and combines elements of OOP (Object Oriented Programming), FP (Functional Programming), and FRP (Functional Reactive Programming).

A function is a reusable block of code that accepts arguments and returns a computed value.A pure function always returns the same value given the same arguments and produces no side effects.Let's see in more detail what are pure functions and why they are useful.Before I go on, let me recommend something to you.

The process of studying JavaScript usually begins in a very practical way.From declaring variables to understanding the hell of Asynchronous JavaScript, the more theoretical concepts get left out.And this gap starts to get annoying when you get into deeper topics.With this in mind, let's start by explaining some of the more theoretical (and even philosophical) concepts of Modern JavaScript, starting with purity.

Higher-order functions (HOFs) are functions whose parameters and/or return values are functions themselves.In other words, if a language supports higher-order functions, then we say that these functions are first-class citizens, that is they are values.In this article, we'll investigate how Rust supports higher-order functions and how we can define them.

While fooling around recently with various computer programming algorithms, I ended up writing an implementation of the Adler-32 checksum algorithm in Scala.There isn't too much to say about it, other than I hope I got it right.My results for the simple test below matched the results shown on the Adler-32 Wikipedia page, so that's encouraging.

Harness the power of the web.Typescript framework for building web applications.Xeito is a framework for building efficient, scalable web applications using Typescript.It combines some of the best features of Angular, Vue, React and Svelte to provide you with amazing tools to build your next web application.

Cats Effect is an excellent and performant framework for doing asynchronous computations in a functional manner.It provides an IO monadic datatype for controlling the actions of your application.Effects wrapped in instances of the IO monad are lazily evaluated.They can be conveniently composed together with the flatMap function creating bigger programs and then evaluated in a resource-safe runtime.

In this series of blogs I'll try my best to walk you through the Monads basics & implementations, So stay tuned for the next part!Now, without further ado, let's understand what a Monad is!
Monad is a design pattern used to describe computations as a series of steps.With monads, we can define a pipeline, a series of computational steps, that allow us to reuse more of our code, to write it in terms of highly composable parts.

JavaScript functions are a crucial part of the language, allowing developers to write reusable and modular code.However, there are some advanced concepts related to functions that may not be familiar to all developers.In this article, we'll explore some of the most powerful and advanced features of JavaScript functions, including closures, currying, and higher-order functions.

If you like my books and want to earn a little extra income, I just started using the Gumroad "affiliates" program.Just sign up with Gumroad, link to one or more books, then hopefully make some sales and earn a little extra money.I'm starting with a 30% commission, so if you sell a $10 book like Learn Scala 3 The Fast Way! you'll earn $3, and if you sell a $20 book like Functional Programming, Simplified: Updated for Scala 3, you'll earn $6 (USD).

By Alvin Alexander.Last updated: January 22, 2023


I'm currently writing my new book, Functional Programming, Simplified (Updated for Scala 3) directly in LaTeX, and this is my "LaTeX cheatsheet" that I keep open all the time so I can copy and paste the LaTeX stuff I need while I write.Note that I don't use any LaTeX formula stuff, so most of this is pretty basic LaTeX stuff, though there are a few custom commands/functions that probably won't make sense to anyone unless I share some more details.

As a brief note today, I just released the first version of a new, free booklet that I've titled Learning Recursion.Free download
This booklet is based on the recursion lessons in my new book, Functional Programming, Simplified: Updated for Scala 3. If you've already purchased that book, there's no need to download this booklet, unless you'd like these lessons available in this separate booklet.

As a brief note, here's some Scala source code that shows how to write a fold left ( foldLeft) function using recursion:

// scala 2

object FoldLeft extends App {

val a = List(1,2,3,4)

def add(a: Int, b: Int) = a + b

println(foldLeft(0)(a)(add))

def foldLeft(lastResult: Int)(list: List[Int])(f: (Int, Int) => Int): Int = list match {
case Nil => lastResult
case x :: xs => {
val result = f(lastResult, x)
println(s"last: $lastResult, x: $x, result = $result")
foldLeft(result)(xs)(f)
}
}

}
The output of this example code looks like this:

last: 0, x: 1, result = 1
last: 1, x: 2, result = 3
last: 3, x: 3, result = 6
last: 6, x: 4, result = 10
10
I'll explain this code in my new book on functional programming, but for the moment I'm just sharing the code here in case anyone wants/needs to see how to do this.

In just a few weeks, ODSC and Ai+ Training's Data Engineering Live Summit will arrive.This fully virtual event on January 18th is where you'll want to be to get the latest and greatest when it comes to data engineering.After reviewing our list of speakers, the team's excited about the content that you'll get to enjoy.

As you might guess from looking at this collection of book covers, I LOVE writing about things like Scala and functional programming, but it pays about 1/10th of what programming does.To try to make it affordable to stay in the writing business, I've created this Patreon page.Any support is greatly appreciated!

I like what John De Goes shares in this talk about how to combine the best of FP & OOP.The "best of" portion of the talk starts about 36 minutes into the talk, which is where that link starts.FWIW, I share almost all of the same information in my book, Functional Programming, Simplified, though I will admit that I probably don't articulate it quite as well as his speech.

What if the team hates my functional code?So you learned some functional programming.And it's glorious!Your JavaScript is cleaner; more concise; elegant.It feels solid.You can't wait to share it with the team.So you throw up a PR and wait for the comments to come in; eager to hear what they think.And those comments come in all right.

Meta, parent of Facebook, is in the midst of migrating its Android app Java code to Kotlin, a younger programming language that also relies on the Java Virtual Machine, or JVM.Created by software tool maker JetBrains, Kotlin debuted in 2011 and by 2016 had reached its 1.0 release.The following year, it was adopted by Google as a first-class (supported) language for Android development and was put under the management of its own foundation, funded by JetBrains and Google.

If you ever need to execute AppleScript from a Java or Scala application, this code shows how to solve the programming part of this problem.Given an AppleScript command as a Scala multiline string, like this:

// press the `fn` key twice
val asCommand = """
tell application "System Events"
   key code 63
   key code 63
end tell
"""

you can execute that command by calling this executeAppleScriptCommand method:

val succeeded = executeAppleScriptCommand(asCommand)

whose source code is shown here:

/**
* Executes the AppleScript command you supply as a String.

How about a simple functional programming book written with this style: No monads.No monoids.No category theory.Just some Java & Scala code.Robert Martin's tweet about writing a new simple functional programming book (in Clojure) was shared with me here, and I like his initial wording on not worrying about monads, monoids, functors, and category theory.

Some of the books on the right side of this image are amazing, and I would never discourage anyone from reading the great ones.But if you're an object-oriented programming (OOP) developer who wants to start understanding functional programming (FP) over a weekend, that's the goal of the new little book on the left: Learn Functional Programming Without Fear.

Every line of code you write carries the requirement of maintenance through the lifetime of an application.The more lines of code you have, the more maintenance is required, and the more code you have to change as the application adapts to the evolving requirements.Unfortunately, popular wisdom decrees that we need more test code than application code.

If you've been waiting for a coupon or discount to learn functional programming, today may be your lucky day.I just created a 50% off discount code for the PDF version of "Functional Programming, Simplified" (a best-selling, highly-rated book about functional programming in Scala).But hurry, because the discount is limited to the first 100 buyers.