The document discusses key concepts in functional programming with F#, including:
1. Syntax examples that show how to write functions in F# compared to C#.
2. Functional idioms like composition and pattern matching that allow building programs in a modular way.
3. How the F# type system and compiler checks allow programs to be written in a way that avoids common bugs through techniques like exhaustive pattern matching and units of measure.
Slides from a brief presentation about the 'docase' notation that I did at Haskell Hackathon in Cambridge. The notation makes it easier to work with monads that have some additional operations (such as Par monad or Parsers).
One of the key concepts of functional programming is compositionality – the fact that we can build complex software using several basic “building blocks” and just a few ways of combining them. In this talk, I’ll demonstrate how we can teach this concept using F#. We’ll start with a basic example of this approach that even high-school students can easily understand – numerical expressions. Then we’ll move to more exciting examples of using library for composing 3D graphics. We’ll see that creating a fractal tree is not much more complicated than calculating the area of a triangle.
The recording is available online at: http://www.communityforfsharp.net/
Slides from a brief presentation about the 'docase' notation that I did at Haskell Hackathon in Cambridge. The notation makes it easier to work with monads that have some additional operations (such as Par monad or Parsers).
One of the key concepts of functional programming is compositionality – the fact that we can build complex software using several basic “building blocks” and just a few ways of combining them. In this talk, I’ll demonstrate how we can teach this concept using F#. We’ll start with a basic example of this approach that even high-school students can easily understand – numerical expressions. Then we’ll move to more exciting examples of using library for composing 3D graphics. We’ll see that creating a fractal tree is not much more complicated than calculating the area of a triangle.
The recording is available online at: http://www.communityforfsharp.net/
Workshop slides from the Alt.Net Seattle 2011 workshop. Presented by Wes Dyer and Ryan Riley. Get the slides and the workshop code at http://rxworkshop.codeplex.com/
(Video and code at https://fsharpforfunandprofit.com/pipeline/)
Passing data through a pipeline of transformations is an alternative approach to classic OOP. The LINQ methods in .NET are designed around this, but the pipeline approach can be used for so much more than manipulating collections.
In this talk, I'll look at pipeline-oriented programming and how it relates to functional programming, the open-closed principle, unit testing, the onion architecture, and more. I'll finish up by showing how you can build a complete web app using only this approach.
Python Programming Course Lecture by IoT Code Lab Training.
Discussed Topic:
Chapter 1: Basic Programming
* Operator
* Arithmetic Operation Example
* Assignment Operation Example
* Built in Function Example
* Math Module Example
* Other Operators
* Practice Problem 1.1
* Practice Problem 1.2
* Practice Problem 1.3
following is work on Advance Python part 1 Functional Programming in Python
for code and more details plz do visit
https://lnkd.in/dnQF95z
for more free study material and Projects follow on
Github
https://lnkd.in/gYKtuB3
LinkedIn
https://lnkd.in/daSvf_P
#python #datascience #programming #machinelearning #github #deeplearning #coding #developer #projects #work #developers #linkedin #google #amazonindia#IBM
Chapter 2 Decision Making (Python Programming Lecture)IoT Code Lab
Python Programming Course Lecture by IoT Code Lab Training.
Discussed Topic:
Chapter 2: Decision Making
* Decision Making (Conditional Statement)
* Comparisons Operator Example
* Logical Operator Example
* Bitwise Operator Example
* Practice Problem 2.1
* Practice Problem 2.2
* Practice Problem 2.3
Game of Life - Polyglot FP - Haskell - Scala - Unison - Part 3Philip Schwarz
(download for picture-perfect quality) Follow along as Trampolining is used to overcome Stack Overflow issues with the simple IO monad, deepening you understanding of the IO monad in the process. See Game of Life IO actions migrated to the Cats Effect IO monad, which is trampolined in its flatMap evaluation.
Errata:
slide 33: "impure factorial function" should be "initial factorial function"
slide 34: there is a pointless short vertical bar inside a speech bubble
slide 39: "it is till annoying" should be "it is still annoying"
slide 44: "values that we are interested" should be "values that we are interested in"
(Video of these slides here http://fsharpforfunandprofit.com/rop)
(My response to "this is just Either" here: http://fsharpforfunandprofit.com/rop/#monads)
Many examples in functional programming assume that you are always on the "happy path". But to create a robust real world application you must deal with validation, logging, network and service errors, and other annoyances.
So, how do you handle all this in a clean functional way? This talk will provide a brief introduction to this topic, using a fun and easy-to-understand railway analogy.
Game of Life - Polyglot FP - Haskell, Scala, Unison - Part 2 - with minor cor...Philip Schwarz
(download for picture-perfect quality) Follow along as the impure functions in the Game of Life are translated from Haskell into Scala, deepening you understanding of the IO monad in the process.
This is simply a copy of the original with an error corrected on slides 3 and 52, which were supposed to show Scala code and instead showed the Haskell equivalent! Plus removal of a few minor aesthetic imperfections.
Original: https://www.slideshare.net/pjschwarz/game-of-life-polyglot-fp-haskell-scala-unison-part-2
Workshop slides from the Alt.Net Seattle 2011 workshop. Presented by Wes Dyer and Ryan Riley. Get the slides and the workshop code at http://rxworkshop.codeplex.com/
(Video and code at https://fsharpforfunandprofit.com/pipeline/)
Passing data through a pipeline of transformations is an alternative approach to classic OOP. The LINQ methods in .NET are designed around this, but the pipeline approach can be used for so much more than manipulating collections.
In this talk, I'll look at pipeline-oriented programming and how it relates to functional programming, the open-closed principle, unit testing, the onion architecture, and more. I'll finish up by showing how you can build a complete web app using only this approach.
Python Programming Course Lecture by IoT Code Lab Training.
Discussed Topic:
Chapter 1: Basic Programming
* Operator
* Arithmetic Operation Example
* Assignment Operation Example
* Built in Function Example
* Math Module Example
* Other Operators
* Practice Problem 1.1
* Practice Problem 1.2
* Practice Problem 1.3
following is work on Advance Python part 1 Functional Programming in Python
for code and more details plz do visit
https://lnkd.in/dnQF95z
for more free study material and Projects follow on
Github
https://lnkd.in/gYKtuB3
LinkedIn
https://lnkd.in/daSvf_P
#python #datascience #programming #machinelearning #github #deeplearning #coding #developer #projects #work #developers #linkedin #google #amazonindia#IBM
Chapter 2 Decision Making (Python Programming Lecture)IoT Code Lab
Python Programming Course Lecture by IoT Code Lab Training.
Discussed Topic:
Chapter 2: Decision Making
* Decision Making (Conditional Statement)
* Comparisons Operator Example
* Logical Operator Example
* Bitwise Operator Example
* Practice Problem 2.1
* Practice Problem 2.2
* Practice Problem 2.3
Game of Life - Polyglot FP - Haskell - Scala - Unison - Part 3Philip Schwarz
(download for picture-perfect quality) Follow along as Trampolining is used to overcome Stack Overflow issues with the simple IO monad, deepening you understanding of the IO monad in the process. See Game of Life IO actions migrated to the Cats Effect IO monad, which is trampolined in its flatMap evaluation.
Errata:
slide 33: "impure factorial function" should be "initial factorial function"
slide 34: there is a pointless short vertical bar inside a speech bubble
slide 39: "it is till annoying" should be "it is still annoying"
slide 44: "values that we are interested" should be "values that we are interested in"
(Video of these slides here http://fsharpforfunandprofit.com/rop)
(My response to "this is just Either" here: http://fsharpforfunandprofit.com/rop/#monads)
Many examples in functional programming assume that you are always on the "happy path". But to create a robust real world application you must deal with validation, logging, network and service errors, and other annoyances.
So, how do you handle all this in a clean functional way? This talk will provide a brief introduction to this topic, using a fun and easy-to-understand railway analogy.
Game of Life - Polyglot FP - Haskell, Scala, Unison - Part 2 - with minor cor...Philip Schwarz
(download for picture-perfect quality) Follow along as the impure functions in the Game of Life are translated from Haskell into Scala, deepening you understanding of the IO monad in the process.
This is simply a copy of the original with an error corrected on slides 3 and 52, which were supposed to show Scala code and instead showed the Haskell equivalent! Plus removal of a few minor aesthetic imperfections.
Original: https://www.slideshare.net/pjschwarz/game-of-life-polyglot-fp-haskell-scala-unison-part-2
As programmers, we provide a service to our customers. To create the best possible experience for a customer, we must adhere to our values and beliefs.
Installing and Using Python
Basic I/O
Variables and Expressions
Conditional Code
Functions
Loops and Iteration
Python Data Structures
Errors and Exceptions
Object Oriented with Python
Multithreaded Programming with Python
Install/Create and Using Python Library
Compile Python Script
Resources
===========================
and 7 Quizzes
Deep Dive Into Swift - Presented at Coffee@DBG
In the previous month, Coffe@DBG Covered the basics of Swift, Apple's new programming language. This session introduces some of handpicked interesting features of Swift.
Fun with Lambdas: C++14 Style (part 1)Sumant Tambe
If virtual functions in C++ imply design patterns, then C++ lambdas imply what? What does it really mean to have lambdas in C++? Frankly, I don't know but I've a hunch: It's BIG.
Just like virtual functions open doors to the OO paradigm, lambdas open doors to a different paradigm--the functional paradigm. This talk is not a praise of functional programming or some elusive lambda-based library. (Although, I'll mention one briefly that tops my list these days.) Instead, the goal is to have fun while working our way through some mind-bending examples of C++14 lambdas. Beware, your brain will hurt! Bring your laptop and code the examples right along because that may be the fastest way to answer the quiz.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
4. SYNTAX
int euler1(int max) {
var total = 0;
for(var n=1; n<max; n++) {
if(n % 3 == 0 || n % 5 == 0){
total += n;
}
}
return total;
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#
5. SYNTAX – VS LINQ
int euler1(int max) {
return Enumerable.Range(1, max - 1)
.Where(n => n % 3 == 0 || n % 5 == 0)
.Sum();
}
euler1(1000);
C#
let euler1 max =
[1..max-1]
|> List.filter (fun n -> n % 3 = 0 || n % 5 = 0)
|> List.sum
euler1 1000
F#
6. TYPE INFERENCE
int x = 3;
long y = 4;
var z = x + y; // = 7
C# let x = 3
let y:int64 = 4L
x + y
F#
The type 'int64' does not
match the type 'int'
7. AUTOMATIC GENERALIZATION
val firstInGroup :
g:('a -> 'b) -> list:seq<'a> -> seq<'b * 'a> when 'b : equality
public IEnumerable<Tuple<U,T>> firstInGroup<T,U>
(Func<T,U> g, IEnumerable<T> list) {
return list.GroupBy(g)
.Select(grp => new Tuple<U, T>(grp.Key, grp.First()));
}
C#
let firstInGroup g list =
list
|> Seq.groupBy g
|> Seq.map (fun (key,items) -> key, Seq.head items)
F#
8. GENERALIZE THIS!
int add<T>(T x, T y) where T: op_addition {
return x + y;
}
C#
let add x y = x + y
add 3 4
add 4.2 5.1
F# let inline add x y = x + y
add 3 4
add 4.2 5.1
add "hello" "World"
F#
9. IMMUTABILITY
Eliminate unintended side effects
Sets you up for multi-core programming
Debugging is easier
Testability is higher
Intended side effects are necessary
Performance
10. IMMUTABILITY - EXAMPLE
Example from “Inside F#” blog
let actions = List.init 5 (fun i -> fun() -> i*2)
for act in actions do
printf "%d " (act())
F#
List<Func<int>> actions = new List<Func<int>>();
for (int i = 0; i < 5; ++i) {
actions.Add( () => i * 2 );
}
foreach (var act in actions) {
Console.WriteLine( act() );
}
C#
The mutable variable 'i' is used in an invalid way.
Mutable variables cannot be captured by closures.
Consider eliminating this use of mutation or using a
heap-allocated mutable reference cell via 'ref' and '!'.
12. FUNCTIONS AND FUNCTIONAL TYPES
Which problem would you rather focus on?
a) Where the code should live
b) What the code should do
13. COMPOSITION VS INHERITANCE
Is-a relationship that extends the base class
Very high coupling
Subclasses may not need all functionality from base class
Subclass has to be aware of the base class’s implementation
Ninject StructureMap
Castle WindsorUnity
Interface-dependent
14. FUNCTION COMPOSITION
Pipeline Operator: |>
Return value of first function becomes the last parameter of second function
Forward Composition Operator: >>
Create new functions that are sequences of existing functions
webUrl
|> downloadPage |> extractMetaInfo |> categorizeResource
F#
let categorizeUrl =
downloadPage >> extractMetaInfo >> categorizeResource
let categorizeEmail =
parseEmail >> extractDetail >> categorizeResource
categorizeUrl webUrl
categorizeEmail email
F#
15. FUNCTION COMPOSITION
Partial Application
Create new functions by supplying some of the arguments to an existing function
let MSBuild properties (outputPath:string) (targets:string) =
//Do some msbuild stuff
let MSBuildDebug = MSBuild ["Configuration","Debug"]
let MSBuildRelease = MSBuild ["Configuration","Release"]
F#
* From FAKE
16. PATTERN MATCHING
let data = ("Cleveland", 390000)
let city, population = data
F#
let x = 9
match x with
| num when num < 10 -> printfn "Less than ten"
| _ -> printfn "Greater than or equal to ten"
F#
17. DISCRIMINATED UNIONS
type Shape =
| Square of int
| Rectangle of float*float
| Circle of float
F#
let getArea shape =
match shape with
| Square side -> float(side * side)
| Rectangle(w,h) -> w * h
| Circle r -> System.Math.PI * r * r
F#
let sq = Square 7
let rect = Rectangle 2.2 3.3
let cir = Circle 3.4
F#
19. OBJECT MODELING
* From F# Deep Dives
type MarkdownDocument = list<MarkdownBlock>
and MarkdownBlock =
| Heading of int * MarkdownSpans
| Paragraph of MarkdownSpans
| CodeBlock of list<string>
and MarkdownSpans = list<MarkdownSpan>
and MarkdownSpan =
| Literal of string
| InlineCode of string
| Strong of MarkdownSpans
| Emphasis of MarkdownSpans
| Hyperlink of MarkdownSpans * string
F#
22. UNITS OF MEASURE
unitsOfMeasure.fsx(11,19): error FS0001: Type mismatch. Expecting a
int<mi> []
but given a
int<km> []
The unit of measure 'mi' does not match the unit of measure 'km'
[<Measure>]
type mi
[<Measure>]
type km
// define some values
let mike = [| 6<mi>; 9<mi>; 5<mi>; 18<mi> |]
let chris = [| 3<km>; 5<km>; 2<km>; 8<km> |]
let totalDistance = (Array.append mike chris) |> Array.sum
F#
23. UNITS OF MEASURE
enum DistanceUnit {
Miles,
Kilometers
}
class Run {
private float distance;
private DistanceUnit unit;
public Run(float distance, DistanceUnit unit){
this.distance = distance;
this.unit = unit;
}
}
C#
24. EXHAUSTIVE PATTERN MATCHING
//Model
module Person =
type T = Person of string
let create name =
if String.IsNullOrWhiteSpace(name) then None
else Some(Person name)
let value (Person p) = p
//DAL
let save person =
//put the person in the database…
Some 42
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| None -> printfn "An error occurred"
| Some id -> printfn "The id for %s is %d" (Person.value p) id
F#
25. EXHAUSTIVE PATTERN MATCHING
//DAL
type DatabaseResult<'a> =
| Success of 'a
| UniqueViolation
| GeneralException of Exception
//UI
let readInput name =
match Person.create name with
| None -> printfn "Please supply a name"
| Some p ->
match save p with
| Success(id) ->
printfn "The id for %s is %d" (Person.value p) id
| UniqueViolation ->
printfn "The name %s already exists" (Person.value p)
| GeneralException(ex) ->
printfn "%s" ex.Message
F#
F# language make code easier to understandCan you use F# for a wide range of problems
Small teams, close to businessCut teeth on XPPFP
Who has written any F#?Who gets paid to write F#?A lot like most of you: not an expert.Wanted to stretch my brain like what I see so far I want to share
{} () ; returnNot completely noise…Compiler needs curly bracesIndentingLINQ: adds a lot to readability, but uses:higher order functionsChaining – tied to an interface
Let’s talk about types
- Code reuse! You don’t see the constraints, you see the concepts – the behavior.
"inline“- gives per-type versions of the function, big performance gain over generics- Needed for code that uses overloaded operators – they statically resolve to the default (usually int)
Makes your code more predictableThe default is immutability“minimization” not “elimination”Immutable objects are thread safe
10 10 10 10 100 2 4 6 8
SyntaxGeneralizationImmutability
F# is a hybridThesethings are not available in the C# language
Composition: pass dependencies at runtime into an instance. Operations are interface-dependentLook back at LINQ exampleTalk about “function composition” in F#...
PipelineDefine a sequence of operationsAny function can be a part of the pipeline – not limited to a particular interfaceForward composition
Great in libraries to create functions that take defaultsOr for eliminating boolean parameters, making existing libraries easier to work with
Decompose or extract specific infoCompare data with a structurelet binding AND program control
“Object reference not set to an instance of an object.”Very important – eliminatesNullReferenceExceptionsWith pattern matching, forces client code to check for None
Simple to understandInstead of strings named “Literal”, “Literal” is a type
Model: use functional types to concisely represent complex object models (especially hierarchies)Flow: most appsTake data inDo some workShow results of workBecause immutable, your thinking changes from “mutate the object” to represent the results to “transform” some data
Compilers are nice because they tell us when we do something bad.What if the compiler was more proactive (like in the immutability example)?
Annotate values in your code with units
Just a structure. Not even values…. “new” up a bunch, etc.Think of the work to get the compiler to tell you when you attempt to add miles and kilometers!point: I’m sure it’s possible. But it won’t be nearly as concise or readable.
You have to deal with return values.
Patterns are exhaustiveNot only detects missingImpossibleRedundant
Have to know what the state of the model is compared to the state of the database
UOM: always compare apples to applesPM: compiler checks for edge cases; forces you to dealTP: don’t worry about state of two disconnected things
Same input, same output; test in isolationCreate functions that solve small problems in your domain (Lego™ blocks), then combine themCreate types that enforce correctness, and force clients to follow the rules
Don’t ignore other functional languages – like OO, there’s a lot to learn from other languagescaml or lisp basedThink polyglot – use functional where you think you can.