Code Monkey home page Code Monkey logo

learn4haskell's Introduction

learn4haskell

Learn4Haskell

🚨 Important notice: This course continues BAU even after Hacktoberfest 🚨

You can find the results of Hacktoberfest 2020 for Learn4Haskell in the following blog post:


It's the time of the year when thousand pull requests are starting to float in the air like a leaf on the wind πŸƒ

It's Hacktoberfest! And we are happy to be part of this fantastic event.

Usually, people contribute to projects within the communities they spend most of their time already and don't try to go out of those boundaries. But why not use this time to learn something challenging, something fresh, something that you never had time for?

You can get the benefits of Hacktoberfest while learning something new fascinating concepts – Functional Programming with Haskell.

And we're here to help!

  • 4 Pull Request to get the T-Shirt or plant a tree as stands in the Hacktoberfest rules.
  • 4 Pull Request to learn to program in Haskell.
  • 4 Pull Request to blow your mind.

Table of Contents

What is Learn4Haskell

Learn4Haskell is a GitHub-located course that will get you into the Haskell Functional Programming world in just 4 Pull Requests.

This course is organised as a coding project. So you can complete the course without needing to exit your editor.

This works in the following way. When you decide to start the project, all you need to do is to fork the project. We have prepared 4 separate modules β€” chapters. Each part contains educational material and lots of examples that we provide in a simple form that doesn't require you to know anything about functional programming beforehand. Also, each chapter contains several exercises on everything that is explained by us. You can solve the tasks on your way and at the end open a PR to your fork with this chapter's solution and summon us (by shouting out our nicknames there). We would be happy to give you feedback on your progress, explain problematic concepts or just support you mentally!

Each chapter contains unique information and covers different topics. We suggest going through them in order. However, if you think that some of the chapters are already familiar to you, feel free to skip onto the next one. If you would like to talk to us, you can even rely on PRs for the chapter you have questions about.

Chapters are stuffed with information but are aimed to be completed without additional resources. You may spend an evening per chapter, but we swear it's worth it!

At the end of the course, you should be able to independently create and read basic Haskell code and understand Monads and other famous concepts of Functional Programming.

Course Plan

Here is a more concrete plan of the mystical 4 Chapters we prepared for you. These are the highlights of each part.

  • Chapter One – What is Haskell, what are its particularities, basic Haskell syntax, functions, types, expressions.
  • Chapter Two – FP concepts in the language, immutability, pattern matching, recursion, polymorphism, laziness, Higher-ordered functions, partial applications, eta-reduction.
  • Chapter Three – Focus on Types. Type aliases, ADTs, Product types and Records, Sum types and Enumerations, Newtypes, Typeclasses.
  • Chapter Four – Kinds. Three monsters of functional programming: Functor, Applicative, Monad.

Goals

We created the Learn4Haskell project in pursuit of the following goals:

  • Help others to learn Haskell
  • Give a beginner-friendly and self-consistent course with theory and practice in the same place
  • Explain Haskell topics before each task, but strive to be concise and useful at the same time. It's a tough balance!
  • Help people who want to participate in Hacktoberfest and Open-Source, but also want to learn new things during this process
  • Provide review and feedback on solutions, so people are never alone in this challenging yet exciting journey!
  • Give people who completed this course all the necessary understandings to be able to work with basic projects that use standard features. We also intend that you have a strong basis on what they should do to be able to continue their functional programming studies.

Who can participate

Everyone!

We welcome everyone and would be happy to assist you in this journey!

The course is intended for people who don't know Haskell or know only language basics, though.

If you are already an experienced Haskell developer and have come here for learning advanced topics, this course might not be that for you. But you still can help us! Your feedback and suggestions would be helpful for us as well as for the language newcomers who decide to work with this course.

What you will get from this course

This course has many benefits upon completion. Check them out to be sure that it fits your expectations!

Participation in this course would give you:

  • 4 Pull Requests required for Hacktoberfest completion
  • Basic knowledge of the most functional programming language
  • Understanding of the functional programming concepts that you would be able to use in your day-to-day life afterwards
  • On-the-fly feedback and help from experienced Haskell developers and educators
  • Interesting challenges
  • Fun!

Honestly, this seems like a pretty rad deal!

How to get started

Starting to learn Haskell with Learn4Haskell is a piece of cake!

  1. Fork this repository.
  2. ⚠️ Add the hacktoberfest topic to your fork. Otherwise, your PRs won't count.
  3. Enable GitHub Actions for your forked repository.
  4. Install the Haskell compiler.
  5. Open the src/Chapter1.hs file, and start learning and solving tasks!
  6. After you finish the first chapter (or any other chapter, or even if you are stuck in the middle), open Pull Request to your fork with the solution and mention @vrom911 and I would be on our way for the review.

Note, that you should open a PR for your fork of this repo, not this repo. Everyone has their solutions to the included tasks, and they don't mix together well in one repo πŸ™‚

However, if you find some bugs or problems in this repo, you can open a PR to Learn4Haskell directly. We appreciate any help and feedback!

Learn4Haskell has 4 chapters that you can walk through and submit 4 pull requests to complete the Hacktoberfest event (or just for knowledge and your enjoyment).

So, you can start right now with forking. Following this we'll describe how you can install all the necessary items to be able to run this course locally.

Installing Haskell

If you're on Windows, install the haskell-dev and make packages using Chocolatey.

choco install haskell-dev make
refreshenv

If you're on Linux or macOS, then the process is easy:

  1. Install ghcup and follow ghcup instructions for successful installation (remember to restart your terminal afterwards to avoid an unknown ghcup command error on the next step).

  2. Install the latest version of the Haskell compiler β€” GHC β€” and the Cabal build tool. After you install ghcup, it is easy to install the rest with a few commands from your terminal

    ghcup install ghc 9.2.4
    ghcup set ghc 9.2.4
    ghcup install cabal 3.2.0.0
  3. Run cabal update to fetch the latest info about Haskell packages.

Haskell IDE

If you don't have any IDE preferences, we recommend installing Visual Studio Code with the Haskell plugin. The mentioned plugin would give you everything required to immediately start coding with Haskell.

Gitpod

Open in Gitpod

Gitpod is a VSCode-based Web IDE. With it, you can get a Haskell environment out-of-the-box. It's free to use up to 50 hours per month.

Just prepend gitpod.io# to your repo URL and you are ready to go. It will take some time to initialize the workspace for the first time it opens. It only keeps changes under /workspace, and it will be deleted after a period of inactivity unless it's pinned.

How to develop

The course assumes that you install Haskell tooling (GHC and Cabal), edit code in the corresponding chapters, run GHCi (Haskell interpreter, explained in the course) from the root of this project and load your chapters to check your code. Don't worry, each chapter explains all the needed information!

We also provide a Makefile with commands to test your solutions locally with the included prepared test-suite. We have also configured the CI using GitHub Actions on Learn4Haskell to check your answers at GitHub automatically!

To run all tests for Chapter One:

make test-chapter1

To run tests only for basic tasks for Chapter One (without the advanced tasks):

make test-chapter1-basic

Similar commands are provided for all chapters from One to Four.

Who we are

I am Veronika (@vrom911) and I drive this open source organisation β€” Kowainik. We have a lot of open source projects and libraries in Haskell that are used in the Haskell community. We are also working on a lot of tutorials and guides in Haskell and mentoring people who are keen to learn Haskell as well.

We are passionate about Functional Programming and Haskell in particular. But at the same time, we understand how difficult it can be to get into all these ideas on your own. That is why we've decided to start this course to help newcomers. With the interactive learning process and live discussions we've included, Haskell will not be that scary. We will do our best so that it especially won't be the case for you or any others participating here!

How can you help

You can help us by supporting us on Ko-Fi or via GitHub sponsorship program:

We also appreciate any feedback on our course a lot! You can submit your feedback using the following form:

learn4haskell's People

Contributors

aelbozie avatar alexkassil avatar arpl-c-63h avatar arumugamtp avatar burenkov-anton avatar chshersh avatar d-l-n avatar dariodsa avatar dependabot[bot] avatar graceful-potato avatar hasrthur avatar imba-tjd avatar isthatcentered avatar iwanttokeepanon avatar krivtsov avatar marcellourbani avatar mediumdoggo avatar mjcz-archived avatar pennychase avatar pro2s avatar recluse27 avatar ridoca avatar staff0rd avatar sylk avatar thanakritju avatar thth avatar vrom911 avatar

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

learn4haskell's Issues

Odd test output results

Hi, first thanks for making this kowainik!

I'm getting some weird output from the tests:

src/Chapter1.hs:221: failure in expression `:t (&&)'
expected: (&&) :: Bool -> Boolean -> Bool
but got: (&&) :: Bool -> Bool -> Bool

Looks to me like the "expected" (which is my incorrect answer) is switched with "but got".

Also, the output seems to jump around, going from complaining about line 221 to line 305, even though there are many tests between there:

Test suite doctest-chapter1: RUNNING...
src/Chapter1.hs:221: failure in expression `:t (&&)'
expected: (&&) :: Bool -> Boolean -> Bool
 but got: (&&) :: Bool -> Bool -> Bool
                              ^
src/Chapter1.hs:305: failure in expression `(3 + 5) < 10'
expected: <INSERT THE RESULT INSTEAD OF THE TEXT>
 but got: True
          ^

Now, this could be my fault, because I needed to bump up base to 4.15, and doctest to 0.18 in order to get the cabal build to run in docker/haskell.

README.md: *boiling

It looks like there's a typo in README.md: "...people are contributing to projects within the communities they are
boiling in." Are you sure you wanted to use the verb "boil" here? I mean, I can imagine that tempers can flare up sometimes in programming communities, but I never thought the temperature would reach boiling point ;)

Ideas for new tasks/changes to the existing tasks

Just a collection of some ideas to improve the course and make some tasks better. A few things I have on my mind and discussed with @vrom911:

  • Chapter 1: A simpler task before lastDigit that doesn't require thinking about corner cases.
  • Chapter 2: Maybe eta-reduction task where you shouldn't eta-reduce?
  • Chapter 3: A task on typeclasses to write the type of a function like foo x y = show (x + y).
  • Chapter 3: Make sure that the first fight is only one round, no recursion.
  • Chapter 3: Clarify, that in Append people don't need to create a separate List newtype for lists.
  • Chapter 4: The advanced task can make use of Monads to practice this topic more.

SPELLING ERROR

IN THE README THERE IS A SPELLING ERROR #98
CHANGED "ETA REDUCTION" TO "BETA REDUCTION"

Save @vrom911's and @chshersh's time by including solutions

Thank you @vrom911 and @chshersh for this fun course! Just the right difficulty level for a 'confidence building' break from Haskell Programming From First Principles.

I'm finding myself searching through PRs to see solutions - sometimes I need a hint, and sometimes I just want to see other solutions, or what you've said to others.

Instead of you reviewing many PRs with the same basic solutions, many of us could review our own if there was a set of solutions provided - maybe even just taken from a PR you thought had the best solutions?

Thank you again for all the work you've put into this.

Unable to open pull request for Chapter 4

Dumb question, guys.

Somehow I'm unable to open the last pull request.

On my forked repo I can see the latest commit, with Chapter 4 solutions. Then, if I open the "create a pull request" link I can't see the usual embedded editor from which I can add a description and then open the pull request.

Any ideas? Thanks

[error] Function Definition in GHCi on Linux 5.8

Hey Awesome people, First of all thank you very much for the amazing idea of learning Haskell in 4 PRs with Hacktoberfest (I
absolutely love the Idea ❀️ )

I'm trying to define a function in Glassgow Haskell Compiler's REPL by executing the following line :

prelude> roundSubtract :: Double -> Int -> Int

and It results in the following error:

<interactive>:3:1: error:
    β€’ No instance for (Show (Double -> Int -> Int))
        arising from a use of β€˜print’
        (maybe you haven't applied a function to enough arguments?)
    β€’ In a stmt of an interactive GHCi command: print it

On the tutorial, In Chapter1.hs, on line 358, It asks to do it.

CC: @chshersh @vrom911

doctest failed

I have solutions for Chapter1.

Test suite doctest-chapter1: RUNNING...
src/Chapter1.hs:298: failure in expression `1 + 2'
expected: 3
          it :: Num a => a
 but got: 3
          ^

but I have in code:

>>> 1 + 2
3
it :: Num a => a
>>> 10 - 15

Something wrong...

Build dependency happy fails on OSX 10.15.7

See haskell/happy#180 and

➜ make test-chapter2
cabal test doctest-chapter2 --enable-tests --test-show-details=direct
Build profile: -w ghc-8.10.1 -O1
In order, the following will be built (use -v for more details):
 - learn4haskell-0.0.0.0 (test:doctest-chapter2) (first run)
Preprocessing test suite 'doctest-chapter2' for learn4haskell-0.0.0.0..
Building test suite 'doctest-chapter2' for learn4haskell-0.0.0.0..
Running 1 test suites...
Test suite doctest-chapter2: RUNNING...
Examples: 54  Tried: 54  Errors: 0  Failures: 0
Test suite doctest-chapter2: PASS
Test suite logged to:
/Users/xxx/code/learn4haskell/dist-newstyle/build/x86_64-osx/ghc-8.10.1/learn4haskell-0.0.0.0/t/doctest-chapter2/test/learn4haskell-0.0.0.0-doctest-chapter2.log
1 of 1 test suites (1 of 1 test cases) passed.
cabal run learn4haskell-test --enable-tests -- -m "Chapter2"
Build profile: -w ghc-8.10.1 -O1
In order, the following will be built (use -v for more details):
 - happy-1.20.0 (exe:happy) (requires build)
 - pretty-show-1.10 (lib) (requires build)
 - hedgehog-1.0.4 (lib) (requires build)
 - hspec-hedgehog-0.0.1.2 (lib) (requires build)
 - learn4haskell-0.0.0.0 (test:learn4haskell-test) (first run)
Starting     happy-1.20.0 (exe:happy)
Building     happy-1.20.0 (exe:happy)

Failed to build exe:happy from happy-1.20.0.
Build log ( /Users/xxx/.cabal/logs/ghc-8.10.1/hppy-1.20.0-9ac48e58.log ):
Configuring executable 'happy' for happy-1.20.0..
Preprocessing executable 'happy' for happy-1.20.0..
Building executable 'happy' for happy-1.20.0..
[ 1 of 19] Compiling AbsSyn           ( src/AbsSyn.lhs, dist/build/happy/happy-tmp/AbsSyn.o )
[ 2 of 19] Compiling GenUtils         ( src/GenUtils.lhs, dist/build/happy/happy-tmp/GenUtils.o )
[ 3 of 19] Compiling NameSet          ( src/NameSet.hs, dist/build/happy/happy-tmp/NameSet.o )
[ 4 of 19] Compiling ParamRules       ( src/ParamRules.hs, dist/build/happy/happy-tmp/ParamRules.o )
[ 5 of 19] Compiling ParseMonad       ( src/ParseMonad.hs, dist/build/happy/happy-tmp/ParseMonad.o )
[ 6 of 19] Compiling Lexer            ( src/Lexer.lhs, dist/build/happy/happy-tmp/Lexer.o )
[ 7 of 19] Compiling AttrGrammar      ( src/AttrGrammar.lhs, dist/build/happy/happy-tmp/AttrGrammar.o )
[ 8 of 19] Compiling AttrGrammarParser ( src/AttrGrammarParser.hs, dist/build/happy/happy-tmp/AttrGrammarParser.o )
[ 9 of 19] Compiling Grammar          ( src/Grammar.lhs, dist/build/happy/happy-tmp/Grammar.o )
[10 of 19] Compiling LALR             ( src/LALR.lhs, dist/build/happy/happy-tmp/LALR.o )
[11 of 19] Compiling First            ( src/First.lhs, dist/build/happy/happy-tmp/First.o )
[12 of 19] Compiling Parser           ( src/Parser.hs, dist/build/happy/happy-tmp/Parser.o )
[13 of 19] Compiling Paths_happy      ( dist/build/happy/autogen/Paths_happy.hs, dist/build/happy/happy-tmp/Paths_happy.o )
[14 of 19] Compiling Info             ( src/Info.lhs, dist/build/happy/happy-tmp/Info.o )
[15 of 19] Compiling PrettyGrammar    ( src/PrettyGrammar.hs, dist/build/happy/happy-tmp/PrettyGrammar.o )
[16 of 19] Compiling ProduceGLRCode   ( src/ProduceGLRCode.lhs, dist/build/happy/happy-tmp/ProduceGLRCode.o )
[17 of 19] Compiling Target           ( src/Target.lhs, dist/build/happy/happy-tmp/Target.o )
[18 of 19] Compiling ProduceCode      ( src/ProduceCode.lhs, dist/build/happy/happy-tmp/ProduceCode.o )
[19 of 19] Compiling Main             ( src/Main.lhs, dist/build/happy/happy-tmp/Main.o )
Linking dist/build/happy/happy ...
Undefined symbols for architecture x86_64:
  "___darwin_check_fd_set_overflow", referenced from:
      _awaitEvent in libHSrts.a(Select.o)
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
`clang' failed in phase `Linker'. (Exit code: 1)
cabal: Failed to build exe:happy from happy-1.20.0 (which is required by
test:learn4haskell-test from learn4haskell-0.0.0.0). See the build log above
for details.

make: *** [test-chapter2] Error 1

Bug in est/Test/Chapter1.hs ?

I'm running the code on branch that is synced with your master and get this during make test-chapter1 and make test-chapter2:

test/Test/Chapter1.hs:72:40: error:
    β€’ Couldn't match expected type β€˜Int’ with actual type β€˜Integer’
    β€’ In the second argument of β€˜(===)’, namely
        β€˜(lastDigit (reverseInt x) :: Int)’
      In a stmt of a 'do' block:
        (firstDigit x :: Int) === (lastDigit (reverseInt x) :: Int)
      In the second argument of β€˜($)’, namely
        β€˜do x <- forAll $ Gen.int (Range.linear (- 200) 200)
            (firstDigit x :: Int) === (lastDigit (reverseInt x) :: Int)’
   |
72 |             (firstDigit x :: Int) === (lastDigit (reverseInt x) :: Int)
   |                                        ^^^^^^^^^^^^^^^^^^^^^^^^

test/Test/Chapter1.hs:72:51: error:
    β€’ Couldn't match expected type β€˜Integer’ with actual type β€˜Int’
    β€’ In the first argument of β€˜lastDigit’, namely β€˜(reverseInt x)’
      In the second argument of β€˜(===)’, namely
        β€˜(lastDigit (reverseInt x) :: Int)’
      In a stmt of a 'do' block:
        (firstDigit x :: Int) === (lastDigit (reverseInt x) :: Int)
   |
72 |             (firstDigit x :: Int) === (lastDigit (reverseInt x) :: Int)
   |                                                   ^^^^^^^^^^^^
make: *** [Makefile:22: test-chapter2] Error 1

My implementation of the method seems valid (tested manually both outputs & types):

firstDigit :: Int -> Int
firstDigit n
  | n < 0 = firstDigit (-n)
  | n < 10 = n
  | otherwise = firstDigit $ n `div` 10

Is this wording about typeclasses correct in Chapter3.hs?

Chapter3 says:

As you can see, both monster and knight have similar characteristics, but they
also have some differences. So it is possible to describe their common
properties using typeclasses
, but they are different data types in the end.

Do typeclasses describe their common properties (e.g. health) or the common actions that can be taken on them (e.g. fight)?

Question about a test

Hello,

Just begon with this nice challenge and run into something I do not understand

I have this code :

>>> :t True
True::Bool

and I see a test error which said this :

Test suite doctest-chapter1: RUNNING...
src/Chapter1.hs:211: failure in expression `:t True'
expected: True::Bool
 but got: True :: Bool
              ^
              ```

what is wrong here. For me bith looks the same ?

Error resolving dependencies while make test-chapter1-basic.

Hi!
I am trying the course, after cloning the repo first thing I do is to run a test.
$make test-chapter1-basic

cabal test doctest-chapter1 --enable-tests --test-show-details=direct
Resolving dependencies...
cabal: Could not resolve dependencies:
[__0] trying: learn4haskell-0.0.0.0 (user goal)
[__1] next goal: base (dependency of learn4haskell)
[__1] rejecting: base-4.15.1.0/installed-4.15.1.0 (conflict: learn4haskell => base^>=4.14.0.0)

I am using:

cabal-install version 3.4.0.0
compiled using version 3.4.1.0 of the Cabal library
The Glorious Glasgow Haskell Compilation System, version 9.0.2

which I have installed and configured following this guide
I have tried modifying learn4haskell.cabal and removing version constraint, which resulted in a failure in a different dependency.

Please comment on possible solutions or workarounds. Thank you

Chapter2: takeEven or dropEven?

{- |
=βš”οΈ= Task 7
Write a function that takes elements of a list only in even positions.
πŸ•― HINT: You need to write a recursive function that pattern matches
  on the list structure. Your function will have several cases and
  probably needs to use nested pattern matching on lists of size at
  least 2. Alternatively, you can use the "Recursive go" pattern.
>>> takeEven [2, 1, 3, 5, 4]
[2,3,4]
-}

Shouldn't it be dropEven or takeOdd?

Property testing

  • Typeclass laws
  • duplicate: length (duplicate xs) = 2 * (lenght xs)
  • rewind = reverse

Main project description

  • What is it
  • Goals
  • Is it suitable for you?
  • How to participate
  • How to open PRs and ask our review
  • ???

Useful to have docker instructions in README.md?

I have Haskell already installed on my system, and that includes stack but not cabal.
So, in order to run the tests for this course, I installed ghcup in Docker, then cabal, and ran the tests there.

Would a PR with instructions for how to do this be useful? Or a Dockerfile even?

Chapter 3 knight Monster clarification

@vrom911 @chshersh Some clarifications needed please ?

Prepare to defend the honour of our kingdom! A monster attacks our brave knight.
Help him to fight this creature!
Define data types for Knights and Monsters, and write the "fight" function.
Both a knight and a monster have the following properties:
 ✦ Health (the number of health points)
 ✦ Attack (the number of attack units)
 ✦ Gold (the number of coins)
When a monster fights a knight, the knight hits first, and the monster hits back
only if it survives (health is bigger than zero). A hit decreases the amount of
health by the number represented in the "attack" field.
Implement the "fight" function, that takes a monster and a knight, performs the
fight following the above rules and returns the amount of gold the knight has
after the fight. The battle has the following possible outcomes:
 βŠ› Knight wins and takes the loot from the monster and adds it to their own
   earned treasure
 βŠ› Monster defeats the knight. In that case return -1
 βŠ› Neither the knight nor the monster wins. On such an occasion, the knight
   doesn't earn any money and keeps what they had before.

It seems the question is not really clear, should this be interpreted as a fight between knight and monster with multiple rounds
or a single round ?

Based on this commit from a PR and many other PR's which are similar and accepted as an answer. I don't understand, how can the below function be true based on the following data:

balrog :: Monster
balrog = Monster {
          monsterHealth = 97,
          monsterAttack = 5,
          monsterGold   = 70
         }

arthur :: Knight
arthur = Knight {
          knightHealth = 93,
          knightAttack = 7,
          knightGold   = 82
         }


fight (Knight _ knightHealth knightAttack knightGold) (Monster monsterHealth monsterAttack monsterGold)
    | knightAttack >= monsterHealth = knightGold + monsterGold
    | monsterAttack >= knightHealth = -1
    | otherwise = knightGold

Based on the first condition knightAttack >= monsterHealth will be false, hence Arthur loses, but in fact if the fight goes on until either is dead (health 0) then Arthur would win.

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    πŸ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. πŸ“ŠπŸ“ˆπŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❀️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.