Since rust Python can theoretically access Tokio does it make it avoid the cpython gil issues
216 karma · joined June 17, 2017
keywords: haskell, erlang, elixir, otp, pattern matching, concurrency, stm, message-passing, fp, monads, functors, type-classses, lazy, applicativeDo, streamly, parmonad, async, ocaml, quant, compilers, zen, merkle, bitcoin, xmr, cron, rkt, racket, grenade,weka,hlearn, dao, da*, crypto, gpg, distrubuted, de-centralized, trustless, anonymous, autonomous, libertarian, algorithms, data-structures, surrealism, meditation, yoga, crypto-ownership, cypherpunk, Crypto-anarchy, Cyber-states, Pirate-utopias, proof-of-work, way of tea
email: noloblonoloblo at gmail dot com
bitcoin: 1KQNb23JoQP83exLyxSGQ3zGoXZnMn3k2S
Since rust Python can theoretically access Tokio does it make it avoid the cpython gil issues
This is very simple and scales well for our purposes
Postgres is very powerful. While I sought a short detour in nosql Mongodb land now back to Mysql Postgresql sql territory and glad for it
Being able to generate views is and stored procedures is useful as well.having sql Take over more like ml, gradient descent does open up good possibility.
Also since sql is declarative it Makes it so it's rather easier than imperative scripting languages
why python can't thread? impact of GIL on python https://pythonspeed.com/articles/python-gil/
The rest alt-coins, tokens yes I agree with you are never useful except for grift
Worth a read periodically IMHO
https://www.cs.kent.ac.uk/people/staff/dat/miranda/whyfp90.p...
And then >>=
And then >>=
Declarative by nature and get parallelism and concurrency from the world class ghc runtime ; avoid call back style js, locks mutex, semaphores
Type classes
Type inference
Io capturing the messy real world of state, side effects, io, async concurrency, parallelism
Pure functions or expressions as opposed to imperative Statements
Pattern matching
Monads >>=
Monadic transformers
Maybe Monad equivalent to option type in rust ocaml to avoid null (f# might still have nulls)
Hackage cabal stack and world class libraries
Green threads like erlang Otp elixir
Cloud haskell is haskell's answer to erlang
Lazy default evaluation with strict constraints if needed
Perform unsafeio but explicitly
Immutable by default
Stm software transactional memory when need mutations that compose well
Heavily optimized ghc compiler with fast gc
Type safety Compilers giving errors on type mismatches : trusting the compiler and refactoring with abandon - if it compiles it works
Haskell native compiled code can be Very fast as in golang / ocaml
Tldr haskell makes easy things hard with a steep learning curve and hard things easy as composing is way more useful than Oops. Theoretically, functional programs should: have fewer bugs, be easier to optimize for performance, allow you to add features more quickly, achieve the same outcome with less effort, require less time to get familiarized with a new codebase, etc.
As venerable prof Joe armstrong says you need haskell erlang for fp ; you need c for high performance ; you really don't need cpp Java python c#
Most of these points apply to varying degrees to common lisp racket erlang elixir rust
. bin/activate
pip install dependencies
as Erlang OTP uses a shared nothing architecture
each green thread has it own GC
communication is only via message passing
it is ok to fail over as the threads are easy to replicate as they are cheap
it is possible Golang via ergo as golang gets concurrency right, but doesnt have evolution systems and BEAM
Haskell via cloud haskell might replicate live view... but they are not the sensible defaults as in erlang/elixir/otp
Python never as their async concurrency parallelism story is ill-thought out w GIL limitations. Rust very very hard as their async concurrency design is extremely complex...
Uh-oh. Looks like you’ve run into the dreaded borrow checker!
Are there best practices and how to avoid common sense rust pitfalls!?
so seems safe to me
curl https://alx.sh | sh
to install asahi linux Dual boot on m1 or m2 MacBook apple silicon