title: CS450 layout: true author: Tiago Cogumbreiro lecture: 1 abstract: Course info, arithmetic in Racket, evaluation sep: &nbsp;☽&nbsp; section: 2 semester: f26 <img id="logo" src="data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 124.8 59.6"><defs><style>.b{fill:#005a8b;}</style></defs><path class="b" d="M6.45,43.91c1.38,0,2.52-.32,3.4-.97,.88-.65,1.32-1.52,1.32-2.61,0-.78-.27-1.47-.81-2.05-.54-.58-1.25-.95-2.15-1.09,1.69-.51,2.53-1.52,2.53-3.03,0-.95-.37-1.71-1.12-2.27-.75-.56-1.81-.84-3.19-.84H.28v12.85H6.45Zm-3.38-10.54h2.94c.65,0,1.14,.11,1.46,.32,.32,.21,.49,.57,.49,1.06,0,.93-.65,1.4-1.95,1.4H3.07v-2.77h0Zm0,5.01h2.97c1.49,0,2.24,.54,2.24,1.62s-.75,1.6-2.24,1.6H3.07v-3.21h0Zm10.7,4.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm7.26,1.32c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.25-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.06,1.23-1.06,2.11s.24,1.48,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.36-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.98-.2c.42,.44,.99,.66,1.71,.66h3.07v-2.07h-1.98c-.28,0-.49-.06-.62-.19-.13-.13-.19-.33-.19-.62v-4.31h2.39v-1.98h-2.39v-2.88h-2.61v2.88h-1.93v1.98h1.93v4.79c0,.72,.21,1.3,.62,1.74h0Zm6.76-.43c.92,.92,2.07,1.39,3.45,1.39s2.59-.45,3.49-1.34c.89-.89,1.34-2.07,1.34-3.54s-.45-2.62-1.35-3.52c-.9-.9-2.06-1.35-3.48-1.35s-2.56,.45-3.47,1.35c-.91,.9-1.36,2.07-1.36,3.52s.46,2.57,1.38,3.5h0Zm3.45-.69c-.66,0-1.18-.24-1.55-.71-.37-.47-.56-1.16-.56-2.07s.19-1.61,.56-2.1c.37-.5,.89-.74,1.55-.74s1.18,.25,1.55,.74c.37,.5,.56,1.2,.56,2.1s-.19,1.59-.56,2.07c-.37,.47-.89,.71-1.55,.71h0Zm9.16,1.78v-4.35c0-1.15,.2-1.97,.61-2.46,.27-.33,.68-.5,1.23-.5,.98,0,1.47,.58,1.47,1.73v5.58h2.61v-6.15c0-1.05-.25-1.87-.76-2.44-.51-.58-1.26-.86-2.27-.86-1.28,0-2.27,.56-2.96,1.69v-1.41h-2.53v9.18h2.61Z"/><path class="b" d="M1.86,25.7c1.05,.95,2.44,1.43,4.19,1.43s3.1-.48,4.17-1.43c1.06-.95,1.6-2.25,1.6-3.87v-7.84h-2.79v7.4c0,2.24-.99,3.36-2.97,3.36-.98,0-1.72-.28-2.22-.85-.5-.57-.75-1.4-.75-2.51v-7.4H.29v7.84c0,1.63,.52,2.92,1.57,3.87h0Zm15.5,1.14v-10.46l3.54,10.46h2.48l3.58-10.48v10.48h2.79V13.99h-4.41l-2.15,6.26c-.4,1.21-.73,2.12-.97,2.74-.24-.61-.57-1.52-.97-2.74l-2.11-6.26h-4.57v12.85h2.79Zm15.13-.44c.55,.49,1.24,.73,2.07,.73,1.38,0,2.43-.54,3.14-1.63,.1,.89,.65,1.34,1.65,1.34h2v-1.98h-.81c-.25,0-.4-.03-.46-.09-.06-.06-.09-.21-.09-.46v-3.36c0-1.17-.35-2.06-1.06-2.66-.7-.6-1.72-.9-3.04-.9-1.25,0-2.27,.28-3.06,.83-.79,.55-1.22,1.21-1.29,1.98l2.35,.51c.23-.97,.91-1.45,2.02-1.45,1,0,1.51,.42,1.51,1.27v.35c-.89,.09-1.67,.21-2.32,.36-.65,.15-1.25,.36-1.78,.63-.53,.27-.94,.62-1.22,1.06-.28,.44-.43,.96-.44,1.56,0,.78,.28,1.42,.83,1.91h0Zm4.39-1.73c-.37,.37-.83,.55-1.38,.55-.8,0-1.19-.33-1.19-.99,0-.54,.26-.93,.77-1.17,.51-.24,1.3-.43,2.35-.57v.59c0,.7-.18,1.23-.55,1.6h0Zm6.38,1.71c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.72,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Zm9.45,0c.8,.48,1.75,.72,2.84,.72,1.32,0,2.36-.27,3.12-.82,.76-.54,1.14-1.28,1.14-2.21,0-1.51-1.05-2.46-3.16-2.86l-1.27-.24c-.49-.09-.82-.19-1-.32-.18-.13-.27-.32-.27-.58s.11-.48,.34-.64c.23-.16,.55-.24,.96-.24,.92,0,1.54,.43,1.85,1.29l2.15-.97c-.24-.58-.7-1.07-1.37-1.49-.67-.42-1.5-.62-2.51-.62-1.21,0-2.17,.26-2.88,.79-.71,.53-1.07,1.23-1.07,2.11s.24,1.47,.73,1.89c.48,.42,1.26,.73,2.32,.94l1.3,.26c.42,.09,.71,.21,.88,.36,.17,.15,.26,.36,.26,.62s-.13,.49-.38,.66c-.25,.17-.59,.26-1.02,.26-.77,0-1.29-.17-1.56-.51-.28-.35-.46-.7-.53-1.03l-2.37,.75c.18,.8,.68,1.43,1.48,1.91h0Z"/><path class="b" d="M123.56,37.95c0-5.44,0-10.89,0-16.33,0-.53-.02-1.06-.04-1.6-.05-1.15-.22-2.29-.47-3.41-1.66-7.41-7.23-13.36-14.5-15.5-1.66-.49-3.36-.78-5.1-.82-.54-.01-1.08,0-1.62,0h-36.56v.4c0,7.18,0,14.36,0,21.54,0,5.25,0,10.51,0,15.76,0,.66,.04,1.33,.08,1.99,.09,1.32,.34,2.61,.69,3.88,1.78,6.46,6.71,11.78,13,14.06,2.38,.86,4.83,1.26,7.36,1.26,5.2,0,10.4,0,15.6,0,.84,0,1.67-.04,2.51-.09,1.04-.06,2.06-.24,3.07-.49,5.22-1.32,9.35-4.21,12.39-8.64,1.68-2.44,2.74-5.14,3.27-8.06,.23-1.3,.32-2.61,.32-3.93h0Zm-20.01-23.79c-.03,.87-.12,1.72-.34,2.56-.3,1.19-.83,2.26-1.68,3.15-.68,.72-1.5,1.24-2.41,1.63-1.07,.46-2.19,.73-3.35,.89-1.26,.18-2.53,.22-3.81,.21-.63,0-1.26,0-1.88,0h-.31V8.19c0-.63,.01-1.26,.11-1.88,.02-.11,.04-.22,.06-.33,.08-.44,.33-.72,.78-.85,.55-.16,1.12-.29,1.69-.34,.67-.06,1.34-.1,2.01-.1,1.32,0,2.62,.18,3.88,.64,2.44,.88,4.03,2.58,4.79,5.06,.38,1.23,.5,2.49,.45,3.77h0Zm2.39,20.48c.32,1.32,.41,2.67,.33,4.02-.06,1.11-.24,2.2-.61,3.25-.87,2.48-2.55,4.2-4.94,5.25-1.01,.44-2.07,.73-3.16,.89-.94,.15-1.89,.22-2.84,.19-.87-.03-1.74-.09-2.58-.35-.94-.29-1.57-.9-1.9-1.83-.23-.66-.35-1.35-.4-2.05-.04-.7-.07-1.39-.07-2.09,0-4.75,0-9.49,0-14.24v-.4c.12,0,.21-.01,.29-.01,1.12,0,2.23-.01,3.35,.01,2.02,.05,4.01,.29,5.95,.88,.99,.3,1.93,.7,2.81,1.25,1.97,1.22,3.2,2.97,3.75,5.21h0Zm15.64,3.79c-.04,4.84-1.74,9.07-5.01,12.64-2.57,2.81-5.72,4.67-9.42,5.58h0c-.91,.23-1.84,.4-2.78,.45-.71,.04-1.43,.09-2.14,.09-5.35,0-10.7,.01-16.05,0-3.78,0-7.26-1.05-10.41-3.13-1.68-1.11-3.14-2.46-4.4-4.04-1.03-1.29-1.63-2.77-1.89-4.4-.18-1.13-.22-2.26-.12-3.39,.1-1.16,.24-2.32,.36-3.49,.12-1.11,.25-2.22,.39-3.33,.13-1.1,.26-2.2,.39-3.3,.11-.96,.22-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.11-.96,.23-1.92,.34-2.88,.11-.95,.23-1.9,.34-2.86,.08-.65,.15-1.3,.24-1.95,.03-.19-.03-.32-.18-.44-.38-.3-.75-.63-1.13-.93-.12-.09-.18-.2-.18-.35,0-.89,0-2.67,0-2.67v-.27h2.45v-4.6h-1.2s2.78-2.17,4.08-3.14c.13-.1,.29-.34,.29-.54-.01-.8,0-1.56,0-2.36,0-.08,0-.16,0-.24,.02-.11,.08-.19,.18-.22,.03-.01,.06-.02,.1-.02,.14,0,.25,.09,.27,.23,.01,.08,0,.16,0,.23,0,.82,.02,1.54,0,2.36,0,.2,.14,.44,.27,.54,1.29,.96,4.11,3.14,4.11,3.14h-1.2v4.6h2.46s0,.29,0,.69c0,.58,0,1.62,0,2.24,0,.14-.05,.24-.16,.34-.41,.33-.8,.67-1.21,1-.12,.09-.16,.19-.14,.34,.1,.87,.19,1.73,.29,2.6,.1,.88,.19,1.75,.28,2.63,.1,.89,.2,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.1,.88,.19,1.75,.28,2.63,.1,.9,.2,1.8,.29,2.7,.09,.88,.19,1.75,.28,2.63,.1,.89,.19,1.79,.29,2.68,.09,.88,.19,1.75,.28,2.63,.12,1.13,.19,2.28,.47,3.39,.09,.35,.19,.71,.32,1.05,.5,1.35,1.44,2.26,2.78,2.76,.74,.27,1.51,.43,2.29,.52,1.19,.13,2.38,.2,3.58,.15,1.26-.05,2.53-.1,3.79-.2,1.88-.16,3.73-.45,5.55-.92,.61-.16,1.21-.33,1.81-.53,2.11-.7,4.08-1.66,5.86-3,1.92-1.44,3.48-3.19,4.54-5.36,.68-1.41,1.09-2.9,1.25-4.46,.2-1.97,.04-3.9-.6-5.78-.76-2.22-2.12-4-3.99-5.42-1.48-1.12-3.12-1.91-4.86-2.5-.49-.17-1-.31-1.5-.47-.08-.03-.16-.05-.31-.09,.13-.07,.21-.11,.29-.15,1.17-.55,2.28-1.21,3.29-2.02,2.31-1.84,3.8-4.19,4.28-7.12,.52-3.13,.03-6.1-1.62-8.84-.1-.16-.22-.34-.36-.53-.83-1.06-2.26-2.39-2.3-2.46,.08,.02,.16,.04,.24,.07,5.41,1.89,9.26,5.47,11.54,10.73,.66,1.53,1.08,3.13,1.29,4.78,.1,.77,.16,1.55,.16,2.32,.01,5.8,.05,11.61,0,17.41h0ZM75,14.04s1.98,0,2.98,0c0-1.55,0-4.61,0-4.61h-2.98v4.6h0Zm42.41,45.14v-2.54h.95v-.34h-2.28v.34h.95v2.54h.38Zm1.7,0v-2.45l.83,2.45h.34l.84-2.41v2.41h.37v-2.88h-.51l-.69,2c-.07,.2-.12,.36-.15,.46-.03-.09-.07-.24-.14-.43l-.68-2.04h-.57v2.88h.37Z"/></svg>" height="64" /> .bottom-bar[ {{title}} {{sep}} {{abstract}} {{sep}} Lecture {{lecture}} {{sep}} {{author}} ] --- class: middle # {{title}} ## Structure of Higher Level Languages ### Lecture {{lecture}}: {{abstract}} ### {{author}} --- # About the course * **Instructor:** Tiago (蒂亚戈) Cogumbreiro .alt[(he/him)] ## How to reach me * **Office hours** in person (have priority), or remotely via Zoom * **Announcements** in `#cs450-news-{{section}}` (Discord) * **Q&A** in `#cs450-{{section}}` (Discord) --- # How we are doing remote teaching * **Open door policy, via Discord.** * Message me at any time, any day with your questions. * Channel questions answered first, direct-messages answered second. * I reply as soon as possible, during office hours in the latest. * **Homework assignments** we use a grading server (Gradescope) ## Course webpage .center[ [`cogumbreiro.github.io/teaching/cs450/{{semester}}-{{section}}/`](https://cogumbreiro.github.io/teaching/cs450/{{semester}}-{{section}}/) ] --- # Syllabus .center[ [`cogumbreiro.github.io/teaching/cs450/{{semester}}-{{section}}/syllabus.pdf`](https://cogumbreiro.github.io/teaching/cs450/{{semester}}-{{section}}/syllabus.pdf) ] .space-top.small[ | A | A-| B+ | B | B- | C+ | C | C-| D+ | D | D- | F | |--------:|---|-|-|-|-|-|-|-|-|-| | .small[100..95] | .small[94..90] | .small[89..85] | .small[84..80] | .small[79..75] | .small[74..70] | .small[69..65] | .small[59..55] | .small[54..50] | .small[49..45] | .small[44..40] | .small[39..0] | ] .space-top[] .row[] .col-6[ * Course divided into 9 modules * 1 homework assignment per module * Final grade: 95% homework + 5% participation ] .col-6[ * *Homework grade:* average of **9 assignments** (possibly weighted) * **You must pass 7** out of 9 assignments. If you fail 3 or more assignments (<40 points), then you fail the course. ] --- class: impact # Course requirements --- # Course requirements ### Checklist * Install Racket >=8.2: [`racket-lang.org`](https://racket-lang.org/) * Sign in on GitLab (invitation by email) * Sign in on Discord, say "Hi" in `#cs450-lounge-{{section}}` (invitation link in the GitLab page) * Sign in on Gradescope, upload the template `hw1.rkt` (invitation by email) ## Heads up * Please, .alt[**register using your UMB email address**], otherwise you won't be able to submit your first homework. * The deadline of homework assignment `n` is last class of module `n` plus 1 week --- class: impact # Why learn # the Structure of # Higher Level Languages? --- # Structure of Higher Level Languages > I postponed this discussion, because I felt that you are now better suited to understand and relate to the points being made. * Why learn the fundamental concepts in all programming languages? * Why learn different languages? * Why focus on functional programming? * Why use Racket? ### Disclaimer * Most of these claims are opinions * These will be mostly informal claims * We are **not** trying to find the best language (or programming model) --- # Overview * Languages are just tools, learn which language is amenable to what context * The best programming language does not exist (theoretically most languages are equivalent) * Different languages have different characteristics that favor different domains: for instance, functional languages being used in Programming Language research, C/Fortran in scientific/high-performance computing * A programming language is a computing interface: it is crucial to understand its meaning * The importance of first-class functions and avoiding mutation --- # Semantics and idioms ### Why should we care about language semantics? * **A language is a *computing user interface*.**<br/> We are learning reusable, cross-cutting patterns. * **The semantics must be *unambiguous* and *precise*.**<br/> It is not a matter of personal opinion how a conditional expression works. Language features must be described unambiguously to users. * **The semantics defines a software contract.**<br/> Is the bug in the client's bug, or is it in our code? * **Language idioms (patterns) are transferrable knowledge.**<br/> Understanding idioms (patterns) teaches you something that can be applied across languages and technologies. --- class: impact # How are all languages similar? --- # How are all languages the same? * **Theoretical:** Any input-output behavior implementable in language X is implementable in language Y ([Church-Turing thesis](https://en.wikipedia.org/wiki/Church%E2%80%93Turing_thesis)), and *equivalent to the $`\lambda`$-calculus without numbers* * **Practical:** Reoccurring fundamentals: variables, abstraction, recursive definitions --- class: impact # How are languages different? --- # Disclaimer ## Languages are not slow/fast * A language **implementation** is fast/slow, not the language itself * Certain languages computational models are more amenable to implement efficiently * Languages are user interfaces of computational models .center[ ## How different languages behave in different contexts? ] --- # Why is C faster than all other languages? > Is it because C is "close to the metal?" That is, is C fast because its semantics matches the processor's semantics? -- **No!** * Which processor? How could it match the semantics of all processors? * Which compiler? The key of C's success lays in having good compilers. * C compilers are fast because C is **old and its interface remains stable**! * Popular C compilers are **really** good at optimizing the target language. * There is a set of good practices to write optimizer-ready C code ### Take away > The facts above make C quite successful in High Performance Computing (large scale scientific > codes). .small[ Source: [*C Is Not a Low-level Language: Your computer is not a fast PDP-11*. David Chisnall. ACM Queue vol. 16, no. 2. 2018](https://queue.acm.org/detail.cfm?id=3212479) ] --- # Why is Python slow multithreading? - CPython (the main implementation of Python) is conditioned by the GIL (the Global Interpreter Lock) which effectively serializes parallel execution - To parallelize code we must run multiple processes, where shared memory is especially slow, which, in turn, slows down compute-bound programs ### Take away > Avoid running compute-bound parallel codes in Python. Maybe choose C? .small[ Source: [Global Interpreter Lock. Python Wiki. Last edit in 2017, accessed in 2019.](https://wiki.python.org/moin/GlobalInterpreterLock) ] --- # Constraint language programming > We solve the equation `SEND+MORE=MONEY` where each letter represents a digit in Prolog using a constraint language programming module: ```prolog sendmore(Digits) :- % Source: https://en.wikipedia.org/wiki/Constraint_programming Digits = [S,E,N,D,M,O,R,E], % Create variables Digits ins 0..9, % Associate domains to variables S #\= 0, % Constraint: S must be different from 0 M #\= 0, all_different(Digits), % all the elements must take different values 1000*S + 100*E + 10*N + D % Other constraints + 1000*M + 100*O + 10*R + E #= 10000*M + 1000*O + 100*N + 10*E + Y, label(Digits). % Start the search ``` ### Take away > Some problems are more amenable to certain programming languages. --- # How are languages different? 1. **The implementation matters:** A language implementation may be conditioned (faster/slower) in certain contexts 2. **The model matters:** Certain problems are simpler/more efficient to write in specific languages 3. **The domain matters:** A technology your business needs may only be available in some language (say TensorFlow in Python) --- # Why learn different languages? > Learn at least one new language every year. Source: [*The Pragmatic Programmer.* Andrew Hunt and David Thomas. 1999. ](https://pragprog.com/book/tpp/the-pragmatic-programmer) .space-above[ ### Why should you care * Deeper understanding of the differences and the similarities between languages * Learn different approaches to the same problems * More job opportunities * Better technology choices (some technologies are only available in specific languages) ] --- class: impact # Why functional programming? --- # What is functional programming? * Mutation is discouraged * Higher-order functions serve as a generalization device ## Why should we care? * These features help designing correct, elegant, and efficient software * Functional programming languages are heavily favored by PL researchers, which means they serve as **a test bed for PL design**. Functional programming is close(r) to math formalism, thus implementation is usually simpler in functional programming languages. * **Functional programming is trendy!** C++/Java/C#/Python/JavaScript are all incorporating functional programming idioms. --- # Why should we discourage mutation? * Simpler to reason about: no surprises passing a data-structure to functions/objects * Concurrency-ready: read-only means no race conditions (and no locks), which leads to simpler, faster code ## Who is using it? * `immutable.js` for JavaScript by Facebook * `vavr`, `PCollections`, the Scala runtime, and the Closure runtime for Java * `immer` for C++ * immutable collections for .NET ??? https://doi.org/10.1016/0022-0000(89)90034-2 --- # Why should we use higher-order functions? * Simpler interface than objects (which method? which order?) * Can be combined effectively (frameworks on combining functions) --- # A researcher's Petri Dish > Most programming languages features started out in functional programming > languages. * Garbage collection (LISP, 1959) * Generics (Hindley-Milner-Damas type system 1969/1978, [implemented in ML in ~1977](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.5276&rep=rep1&type=pdf) ) * Higher-order functions (`lambda` expressions in C++, C#, Java, Python) introduced in LISP (1959) and in [ISWIM](http://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf) (1966) * Type inference, <i>e.g.</i>, `auto` in C++, `var` in C# (Hindley-Milner-Damas) * Algebraic-data types and pattern matching ([1970s in Hope](http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.18.8135&rep=rep1&type=pdf)) * Recursion --- # A new wave of languages > Many new interesting programming languages * Swift: next-generation programming language for Apple systems * Rust: functional programming meets system programming * F#: an ML derivate for the .NET ecosystem * Elixir: highly-available distributed system * Clojure: a LISP-influenced language for the JVM and the web --- # How are we using functional programming ? * [**OCaml:**](http://www.ocaml.org/learn/companies.html) web development (Facebook/Meta), distributed systems (Docker), finance (Tezos, Jane Street, Bloomberg, Aesthetic Integration), hardware virtualization (Citrix) * [**Haskell:**](https://wiki.haskell.org/Haskell_in_industry) verification (Facebook), distributed systems (Google), compilers (Intel), distributed systems (Microsoft) * [**Erlang:**](https://codesync.global/media/successful-companies-using-elixir-and-erlang/) communication (WhatsApp), ads (AddRoll), web backend (Bet365), finance (Goldman Sachs) * [**Elixir:**](https://codesync.global/media/successful-companies-using-elixir-and-erlang/) spam prevention (Pinterest), micro services (Lonely Planet) * [**F#:**](https://fsharp.org/testimonials/) data analysis (Kaggle), trading (Credit Suisse), gaming backend (GameSys) * [**Racket**](https://www.reddit.com/r/Racket/comments/5g8xse/are_there_any_examples_of_racket_being_used_in/) game scripting (Naughty Dog), image processing (YouPatch) * [**Scala**](https://alvinalexander.com/scala/whos-using-scala-akka-play-framework) middleware (Twitter), database (Netflix), microservices (Tumblr), web (The Guardian) ### Honorable mentions * [ReasonML](https://reasonml.github.io/), [Elm](https://elm-lang.org/), [PureScript](http://www.purescript.org/), [ClojureScript](https://clojurescript.org/) --- class: impact # Course overview --- # This course is **NOT**... * .alt[**on algorithms**<br/>] For a nice free book read [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/) by Jeff Erickson. * .alt[**an introduction on programming and computing**] <br/> For a nice free book read [How to design programs](https://htdp.org/2018-01-06/Book/) by Matthias Felleisen, Robert Bruce Findler, Matthew Flatt, Shriram Krishnamurthi * .alt[**on programming with Racket**]<br/> For a nice free book read [The Racket Guide](https://docs.racket-lang.org/guide/) by Matthew Flatt, Robert Bruce Findler, and PLT --- # This course is... * .alt[**on designing programming language features**]<br/> We will focus mainly on functional and object-oriented programming. * .alt[**on semi-formal specification**]<br/> We will drive our course with precise mathematical notations and tests. * .alt[**on programming patterns**]<br/> We will characterize patterns and study abstractions of these patterns. * .alt[**on purely functional programming**]<br/> We will approach programming without using assignment (mutation). --- # Today we will learn * a formalism to describe a programming language (Racket) * the semantics of a programming language ## How we will learn it > We introduce one language feature at a time 1. **Syntax:** We formalize each language feature (What) 2. **Example:** We illustrate a feature with an example 3. **Semantics:** We introduce how each language feature works (How) --- # Semantics - Abstract *Syntax:* how we write something. Example, which characters/string we use write a keyword, or a number. - *Semantics:* what that something does/means (evaluation here means as the program runs) > In this class, we focus on the **semantics** of programming languages. > We define the semantics of some programming language features. --- class: middle, center # 1. We shall *not* print to output! ## Instead, we will use *assertions*. # 2. We shall *not* mutate variables! ## Instead, we will use *persistent data structures*. # 3. We shall *not* use loops! ## Instead, we will use *recursion*. --- class: impact # Your first program --- class: hl-alt # Program In Racket, **.alt[everything evaluates down to or is a value]**. A Racket program consists of a preamble followed by zero or more expressions: .box.code[ .metavar[program] = .lit[\#lang racket] .metavar[expression]* ] 1. Racket has no end-of-sentence delimiters (contrary to, say, C-like languages which use semi-colons) 2. Racket evaluates each expression from top-to-bottom, left-to-right > For space-constraint reasons, code listings might omit the preamble. ### Language specification * .code.lit[Grayed out text] represents the concrete syntax * .code.metavar[Italic text] represents a meta-variable --- # Expressions ## Expressions can be values, among other things .box.code[ .metavar[expression] = .metavar[value] | $`\cdots`$ ] --- # Values - **Numbers** - Void - Booleans - Lists - ... --- class: impact # Numbers --- # Numbers > *All numbers are complex numbers.* Some of them are real numbers, and all > of the real numbers that can be represented are also rational numbers, > except for `+inf.0` (positive infinity), `+inf.f` (single-precision variant), > `-inf.0` (negative infinity), `-inf.f` (single-precision variant), `+nan.0` > (not-a-number), and `+nan.f` (single-precision variant). Among the > rational numbers, some are integers, because round applied to the number > produces the same number. Source: [Racket Manual, Section 4.2](https://docs.racket-lang.org/reference/numbers.html) --- # Hello, Numbers! ## Your first Racket program .col-6[ ```scheme #lang racket 10 ; A positive number +10 ; The plus sign is optional -10 ; A negative number 0+1i ; A complex number 1/3 ; A rational number 0.33 ; A floating-point number ``` ] .col-6[ ```bash $ racket nums.rkt 10 10 -10 0+1i 1/3 0.33 ``` ] &nbsp; > **Note:** a semi-colon (`;`) initiates a comment section, which is ignored in Racket. > A semi-colon is **not** a end-of-line marker, like in C-like languages. --- # Expressions are separated by white-space These two programs are equal: .row[ .col-6[ ```scheme #lang racket 10 +10 -10 0+1i 1/3 0.33 ``` ] .col-6[ ```scheme #lang racket 10 +10 -10 0+1i 1/3 0.33 ``` ] ] **Caveats:** `-1` is different than `-`.code.lit[&nbsp;]`1` (notice the white space in between both characters). The former is the negative one, the latter is the expression `-` and the value `1`. Similarly, `1/3` is a single rational number, whereas `1 / 3` are three expressions. --- class: impact # Function calls --- # Function call Delimited by parenthesis and its constituents are separated by white-space characters. The first expression must evaluate to a function, the remaining expressions are the arguments. Each expression is evaluated to a value from left-to-right before applying the function. .box.code[ .metavar[expression] = .metavar[value] | .alt.metavar[variable] | .alt.metavar[function-call] | $`\cdots`$ </br> .metavar[function-call] = .lit[(] .metavar[expression-func] .metavar[expression-arg]* .lit[)] ] For instance, function call `(expt 2 3)`, for exponentiation, returns `2` raised to the power of `3`. Function `sin` computes the sine function of its sole argument. .row[ .col-6[ ```scheme #lang racket (expt 2 3) (sin (expt 2 3)) ``` ] .col-6[ ```bash $ racket nums-func.rkt 8 0.9893582466233818 ``` ] ] .small[ > **Note:** Function calls can be compounded, as the parameters of a function are arguments too. ] --- # No infix notation in Racket There is **NO INFIX NOTATION** for arithmetic operations (unlike most languages). The usual arithmetic operations are all just variables: addition `+`, subtraction `-`, multiplication `*`, division `/`. Example: ```scheme ( * 3.14159 ( * 10 10)) | | | | | | |-> Number | | | | | |-> Number | | | | |-> Variable | | | |-> Function call | | |-> Number | |-> Variable |-> Function call ``` > **Note:** In Racket parenthesis represent function application. Contrasted with most > C-like languages where parenthesis in expressions are optional and only there > to help the reader.