並び順

ブックマーク数

期間指定

  • から
  • まで

161 - 200 件 / 209件

新着順 人気順

並列の検索結果161 - 200 件 / 209件

  • Writing Rust the Elixir way

    Bernard Kolobara Posted on Nov 28, 2020 • Updated on Feb 17, 2021 • Originally published at lunatic.solutions It's not a secret that I'm a big fan of Elixir, so when I started doing Rust development I tried to bring some ideas from Elixir to the world of Rust. This post describes some of the tools I'm building to bring the power of Elixir to Rust. What makes Elixir so great? It's hard to just pick

      Writing Rust the Elixir way
    • デッドロック発見器を作って学ぶマルチスレッドプログラミング ★共有変数編★ (2019/10/19 12:30〜)

      セミナーの内容 参加者が自分の好きなプログラミング言語でデッドロック発見器を作り,それを使ってマルチスレッドプログラミングを学ぶハンズオンセミナーです. 作っていただくデッドロック発見器はマルチスレッドプログラムの動き全体を状態遷移図として可視化し,その過程でデッドロック状態を発見するというものです.以下にデッドロック発見器の出力例を示しました. 水色の状態は初期状態で,赤い状態がデッドロック状態です.デッドロック状態からは遷移が1つも出ていないので,この状態に達するとプログラムは停止してしまうことがわかります.動作し続けるパスもあり,必ず再現するわけではないというマルチスレッドプログラムに特徴的な問題であることが見てとれます. セミナーのゴールは,自分で作ったデッドロック発見器を問題に適用して,このような出力を得ることです. マルチスレッドプログラミングの教科書を見ると,典型的なアルゴリ

        デッドロック発見器を作って学ぶマルチスレッドプログラミング ★共有変数編★ (2019/10/19 12:30〜)
      • 並列分散処理基盤のいま~45分で学ぶHadoop/Spark/Kafka/ストレージレイヤSW入門~ - セミナープログラム - オープンソースカンファレンス2020 Online/Kyoto

        並列分散処理基盤のいま~45分で学ぶHadoop/Spark/Kafka/ストレージレイヤSW入門~ 2020年8月28日(金) 17:15 〜 18:00 OSSベースの分散処理基盤としてApache Hadoopが誕生して10余年が経ち、大規模並列分散処理の領域において、これまでに多種多様なソフトウェアが開発されてきました。 本セッションでは、それらのソフトウェアがどのような経緯で誕生し、どのように使われるのかをお話ししつつ、近年注目を集めているデータ分析を指向したストレージレイヤSWであるDelta Lakeについてもご紹介します。

          並列分散処理基盤のいま~45分で学ぶHadoop/Spark/Kafka/ストレージレイヤSW入門~ - セミナープログラム - オープンソースカンファレンス2020 Online/Kyoto
        • Javaの並列/並行処理の基本

          2023.06.29 JJUG Java仕様勉強会資料

            Javaの並列/並行処理の基本
          • ruby/doc/ractor.md at master · ruby/ruby

            You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session. You switched accounts on another tab or window. Reload to refresh your session. Dismiss alert

              ruby/doc/ractor.md at master · ruby/ruby
            • 並列プログラミング処理系Pelemayの
ARMアーキテクチャと
IoTプラットフォームNervesへの適用

              近年ではIoTでエッジ/フォグ・コンピューティングを行う事例が増えてきており,IoTにも計算パワーが求められるようになってきている.そこで,近年,アメリカを中心に注目を集めている開発プラットフォームNervesと,我々が研究開発を進めている並列処理ネイティブコード生成系である Pelemay Super-Parallelism を組合わせて,エッジ/フォグ・コンピューティングに用いることを提案する.現状の Pelemay は Clang / GCC を使って単一コアのSIMD命令を含むネイティブコードを生成する.本研究により,Raspberry Pi 3 Model B+ (ARM Cortex-A53ベース) と Raspberri Pi 4 Model B (ARM Cortex-A72ベース)の Nerves システム上と,Jetson Nano (ARM Cortex-A57ベース

                並列プログラミング処理系Pelemayの
ARMアーキテクチャと
IoTプラットフォームNervesへの適用
              • Rubyで並列処理を行うparallel gemの使い方と勘所 -- ぺけみさお

                parallelを使うとKenrel#forkやThreadを駆使するのと比べて簡単に並列処理を書くことができます。parallelは拙作のBestGems.orgによると、合計ダウンロード数で151位、デイリーダウンロード数は100位前後で、現時点で非常にメジャーなGemとなっています。 この記事ではparallelの基本的な使い方と、実際に使ってみて感じた注意点をTipsとして整理したいと思います。 parallelはREADME.mdが親切に書かれています。 加えて主要な部分は500行程度の小さなGemです。 利用する場合は公式のドキュメントとソースコードを確認されることをおすすめします。 前提ソフトウェア ソフトウェア バージョン 備考 ruby 2.5.1 - parallel 1.12.1 - rails 5.0 - 使い方 インストール gem install paralle

                • Swift 5.5から登場したActorについて

                  サンプルコード https://github.com/SatoTakeshiX/first-step-swift-concurrency/tree/main/try-concurrency.playground 対応するサンプルコードにはページ名を記載します。 検証環境 Xcode 13.2.1 Swift 5.5 データ競合 マルチスレッドプログラミングにおいて、重要な問題はデータ競合(data race)をいかに防ぐかです。複数のスレッドから一つのデータにアクセスした場合、あるスレッドがデータを更新するとデータが不整合を起こしてしまう可能性があります。デバックが非常に難しくやっかいなバグをになることが多いです。 データ競合がどういうものかをコードで解説します。 例えばゲームの点数を管理するScoreという型をクラスで定義します。 // Page: 3-1-data-race class

                    Swift 5.5から登場したActorについて
                  • 分散処理を民主化するRay - Qiita

                    イントロ 日立製作所 研究開発グループの中田です。普段、エッジコンピューティングや分散システムの研究開発、またシステムアーキテクトをやっています。 公私ともにQiitaは初投稿です。 今回は、Rayを紹介します。 Rayは、分散処理を含むアプリを開発するためのライブラリおよび実行環境です。まだ日本では情報が少ないのですが、海外では有名企業や大学がこぞって活用しており、かなりホットなライブラリだと思います。今年2020年10月1日にバージョン1.0がリリースされました。また同じタイミングにRay Summitが開催され、50本程のセッションで多数の活用事例が紹介されました。 Rayは、通常の手続き型言語を容易に分散処理化できるものであり、データ分析やエッジ/IoTの分野で有用に思えるので、日本でも広まって欲しいと思っている次第です。 本記事では、そもそもここでの分散処理とは何か、から始めて、

                      分散処理を民主化するRay - Qiita
                    • ハードウェアの速度をどう評価するか考える(1) ~クロック、OPS~ - arutema47's blog

                      この記事の目的 現代ハードウェアの計算性能を評価する尺度であるメモリ律速の概念とルーフラインモデルについて理解を深めること。 対象読者はメモリバンド幅やOPSなどの概念があまりわかっていない人です。例えば本記事を通し、あるアルゴリズムが速度が十分に出ない時、それがハードウェアのどの性能(メモリか演算)に律速されてるかイメージできるようになるのが目標です。 思うままに書いていたら肝心のメモリの話まで行きませんでした。そのため前編はクロックや演算(OPS)についてです。 TPUのルーフラインモデル この図はTPUの論文に出てくるRoofline modelです。この図が意味するところを理解するのが本記事の最終目標となります。 ハードウェアの速度をどう評価すればいいか? ベンチマークによる評価 ハードウェア速度の評価は昔から大きな問題でした。わかりやすい評価指標にある代表的なアルゴリズム数種類で

                        ハードウェアの速度をどう評価するか考える(1) ~クロック、OPS~ - arutema47's blog
                      • Finding Goroutine Bugs with TLA+

                        My job these days is teaching TLA+ and formal methods: specifying designs to find bugs in them. But just knowing the syntax isn’t enough to write specs, and it helps to have examples to draw from. I recently read Chris Siebenmann’s Even in Go, concurrency is still not easy and thought it would make a good case study for writing a spec. In it, he gives an example of Go code which deadlocks: /*1 */

                        • multiprocessingとグローバル変数

                          2019/12/10 01:00 ※ 商品のリンクをクリックして何かを購入すると私に少額の報酬が入ることがあります【広告表示】 これは DeNA Advent Calendar 2019 の10日目のエントリーです。 9日目は jukey17 さんの Google.Protobuf.Reflectionを利用してC#でProtocol Buffersを汎用的に解析する話 でした。 動作環境など 本エントリに登場するサンプルのコードは次の環境で動作を確認しています。 macOS: 10.15.1 Python: 3.8.0 リポジトリ: https://github.com/tsuyukimakoto/chore_multiprocessing_py38 Python3.8(macOS)のmultiprocessingについて さて、Pythonには GIL(Global Interpret

                          • マルチコアのプログラミングとデバッグに関する課題克服に必要なものとは?

                            本稿では、各種マルチコアプロセッサを紹介し、それらのデバイスが広く使われるようになった理由を含む、マルチコアプロセッシングのさまざまな側面について論じます。また、1個のチップ上に複数のコアを搭載することによって生じる問題に着目し、最新のマルチコア認識型デバッガを使用することで、それらの複雑なタスクにいかに容易に対応できるかを示します。 システム性能 組込みコンピューティングシステムの性能を向上させるには、巧妙なコンパイラアルゴリズムを使用したり、効率的なハードウェアソリューションを実現するなど、多岐にわたる方法があります。例えば、コンパイラの最適化は、読みやすく理解しやすい高水準な言語で書かれたコードから最も効率的な命令スケジューリングを得る上で非常に重要です。また、システムはプロジェクトにおいて、並列処理の利点を生かして同時に複数の処理を行うことができます。もちろん、クロック周波数のスケ

                              マルチコアのプログラミングとデバッグに関する課題克服に必要なものとは?
                            • AsyncCacheのススメ(非同期処理の多重実行防止のための個人的ベタープラクティス)

                              この記事は何? ボタンをタップすることでAPIコールなどの非同期処理を実行するような実装をしている場合に、ボタン連打によって非同期処理が何度も呼び出されてしまう問題を回避するため実装について、個人的なベタープラクティスを伝える記事です。 この記事が対象としている読者 Flutterを使い始めてまだ日が浅い開発者 「Flutterらしい書き方って何だろう」と考えるようになった開発者 「AsyncCacheって何?」と気になった開発者 結論 非同期処理を重複して実行させないような実装を行う際には、asyncパッケージの AsyncCache.ephemeral() を使うと手軽に多重実行を防止できるため便利でおすすめです。 cacheStrategy = AsyncCache.ephemeral(); ~ 省略 ~ ElevatedButton( onPressed: () async { a

                                AsyncCacheのススメ(非同期処理の多重実行防止のための個人的ベタープラクティス)
                              • USB Type-Cによる並列バッテリ充電、この手法は消費者に何をもたらすのか?

                                はじめに USB Type-Cでは、旧世代のUSBと比べてはるかに高い柔軟性が得られます。そのため、USB Type-C(以下、USB-C)に対応するポートは、民生用機器において標準的に使用されるようになりました。そうした機器では、より多くの電力に対応しつつ、より長いバッテリ寿命を実現することが強く求められています。つまり、より高い電力レベルで充電できるようにしなければならないということです。本稿では、まず並列に接続したバッテリを充電(以下、並列バッテリ充電)するためのアーキテクチャについて説明します。その基本とユース・ケースについて押さえた上で、USB-Cを利用して充電を行う方法と得られる効果について解説します。更に、USB-Cを利用した並列バッテリ充電が民生機器の市場にもたらすメリットとデメリットについてまとめます。 並列バッテリ充電とは何なのか? バッテリ管理(バッテリ・マネージメン

                                  USB Type-Cによる並列バッテリ充電、この手法は消費者に何をもたらすのか?
                                • 【Unity】【UniTask】マルチスレッドとしてのTaskからUniTaskを眺める - LIGHT11

                                  Taskのマルチスレッドを実現するための機能という側面からUniTaskについて考えてみます。 はじめに SynchronizationContextとは? TaskAwaiterとTaskのスレッド管理 UniTaskはSynchronizationContextを使わない UniTaskでマルチスレッド 参考 Unity2020.1.10 UniTask 2.0.37 はじめに UniTaskはUnityにおいてTaskの代わりに使えるように作られたライブラリで、処理効率に優れています。 github.com Taskの代わりといいましたが、Taskの役割には「非同期処理」と「マルチスレッド」という二つの側面があります。 そしてこのUniTaskはどちらかというとこのうちの非同期処理の方を代替するためのものとのことです。 UniTaskはどちらかというとJavaScript的(シングル

                                    【Unity】【UniTask】マルチスレッドとしてのTaskからUniTaskを眺める - LIGHT11
                                  • CHAGE | IIJ Engineers Blog

                                    並列処理管理ライブラリ task を含む、l4goの公開 こんにちは、くまさかです。 今回は、Go言語開発を支えるライブラリを公開しましたので、そちらの紹介記事です。 ちなみに今回の記事は、どうしてもGo言語寄りな話が少し登場します。 Go言語に関する説明は… くまさか 2022年02月21日 月曜日 “CHAGE” の大切な要素 こんにちは、CHAGE 開発メンバーの くまさか です。 今回は 5つ目の記事で、CHAGE 紹介シリーズ最後の記事です。 今まで 4つの記事にわたり、CHAGE や ASKS、 連携させる MPPP… くまさか 2020年02月07日 金曜日

                                      CHAGE | IIJ Engineers Blog
                                    • Python の高速化 - MicroAd Developers Blog

                                      はじめに 機械学習エンジニアの大庭です。普段はマイクロアドが提供する広告配信プラットフォーム UNIVERSE Ads に接続する機械学習 API の研究開発をしています。 マイクロアドでは、機械学習モデルの学習側との連携が容易なこととメンテナンス性を重視して Python で機械学習 API を実装しています。Python は使いやすい反面、基本文法は速いとは言えない言語です。そのため、実行時間制約の厳しい Real Time Bidding (RTB) のなかで使うには高速化を意識しておく必要があります。今回は様々ある Python の高速化手法の理解と整理のため記事にしました。 個人的にですが、Python の高速化は以下の手順で行っていくのがいいと思っています。この記事では、この手順毎に便利なツールやライブラリをまとめました。 ボトルネックの特定 計算量(オーダー)を減らす コード

                                        Python の高速化 - MicroAd Developers Blog
                                      • Goroutines Are Not Significantly Smaller Than Threads

                                        Goroutines Are Not Significantly Smaller Than Threads Mar 12, 2021 The most commonly cited drawback of OS-level threads is that they use a lot of RAM. This is not true on Linux. Let’s compare memory footprint of 10_000 Linux threads with 10_000 goroutines. We spawn 10k workers, which sleep for about 10 seconds, waking up every 10 milliseconds. Each worker is staggered by a pseudorandom delay up to

                                        • 【Python】joblibを用いて簡単に『並列処理』を行う方法 - なろう分析記録

                                          今回はPythonのjoblibパッケージを用いて手軽に並列処理を行う方法をご紹介したいと思います。 joblib 『Joblib』とは Joblibパッケージはデータの外部保存や並列処理・並行処理などを簡単に行うために用いるパッケージです。 現在市販されているPCのCUPはマルチコア・マルチスレッドを機能を持つものが一般的となっていますが、デフォルトのPythonではそのうちの1スレッドしか処理に用いられないので、大抵の場合リソースを持て余すことになります。 そこでJoblibを用いた並列処理です。 並列処理を行うことでCUPのリソースをフル活用し、同時に複数の処理を走らせることが出来る様にできます。 Joblibのイメージ joblibの処理の流れとしては『あるリスト』を『ある関数』に送り、最終的に「処理結果のリスト」を得るといった感じです。 イメージ 処理の内容によっては途中で早い・

                                            【Python】joblibを用いて簡単に『並列処理』を行う方法 - なろう分析記録
                                          • マルチスレッド :: やり直しJava

                                            スレッドの現在の状態は ThreadクラスのgetState()メソッドで確認することができます。 スレッド間通信と同期スレッド間通信スレッド間通信と言うと 大袈裟な感じもしてしまいますが、スレッド間でデータをやり取りしたり 待ち合わせを行うことを指します。スレッド間通信は共有メモリを介して行います。共有メモリとして利用できるのは ヒープ領域に置かれたインスタンスやクラスフィールド等です。具体的には次のような方法でスレッド間通信を行うことができます。 クラスフィールドを介してスレッド間通信を行う。クラスのシングルトンオブジェクトを介してスレッド間通信を行う。共有するオブジェクトの参照を それぞれのスレッドで持ち合い、共有オブジェクトを通してスレッド間通信を行う。並列処理を行う場合、スレッド間通信が必要なければ シングルスレッドの場合と変わらないので 難しいことは何もありません。しかし 大抵

                                            • Transformations on Applicative Concurrent Computations - FP Complete

                                              When deciding which language to use to solve challenges that require heavy concurrent algorithms, it’s hard to not consider Haskell. Its immutable and persistent data structures reduce the introduction of accidental complexity, and the GHC runtime facilitates the creation of thousands of (green) threads without having to worry as much about the memory and performance costs. The epitome of Haskell’

                                                Transformations on Applicative Concurrent Computations - FP Complete
                                              • MySQLのMVCCとトランザクション内における集計について

                                                この記事は何? トランザクション分離レベルがRead CommittedなときのMVCCの挙動とトランザクション内における集計で学びがあったので忘備録として共有します。 そもそも、MVCCとは? MVCC(Multi-Version Concurrency Control)は、各トランザクションに一意なバージョンを付与する技術です。データへの同時アクセスが行われた際、各トランザクションが独自のデータバージョンを持つことで、データへの競合を回避させ、並列処理を実現します。このアプローチにより、読み取りと書き込みの操作が相互にブロックされず、システム全体の効率とパフォーマンスが向上します。 Read Committedのトランザクション分離レベルにおけるMVCCの特性は、トランザクション内でデータを読み取る際、そのトランザクションが開始された時点でのコミット済みのデータのみを参照できることです

                                                  MySQLのMVCCとトランザクション内における集計について
                                                • Polkadot: Web3 Interoperability | Decentralized Blockchain

                                                  Polkadot enables cross-blockchain transfers of any type of data or asset, not just tokens. Connecting to Polkadot gives you the ability to interoperate with a wide variety of blockchains in the Polkadot network. Polkadot provides unprecedented economic scalability by enabling a common set of validators to secure multiple blockchains. Polkadot provides transactional scalability by spreading transac

                                                    Polkadot: Web3 Interoperability | Decentralized Blockchain
                                                  • Handling Concurrency Without Locks

                                                    Concurrency is not very intuitive. You need to train your brain to consider what happens when multiple processes execute a certain code block at the same time. There are several issues I often encounter: Failing to recognize potential concurrency issues: It's not uncommon for both beginner and seasoned developers to completely miss a potential concurrency problem. When this happens, and the concur

                                                    • KotlinとCoroutineに入門してみた

                                                      こんにちは、kz_moritaです。 これまではずっと iOS をやっていたのですが、最近サーバーサイド Kotlin を書き始めたので今日は Kotlin の Coroutine について勉強がてら軽く触ってみました。 Kotlin 完全に初心者なので、IDE で project を作るところから詳しめに書いていきます。 準備 開発環境としては、IntelliJ IDEA CE を使う想定なので、別環境の方は適宜読み替えてください。 まずはプロジェクトを作ります。 File > New > Project… Gradle で環境を作るので、以下の写真のように Gradle を選択し、 Kotlin/JVM を選択状態で Next を押します。 GroupId に組織名など(個人の場合は適当で良いはず)をいれ、ArtifactIcd にこのアプリ名を入れます。 Project 名と Pro

                                                        KotlinとCoroutineに入門してみた
                                                      • Javaのsynchronizedの解説と典型的誤り集(記事の誤りや意見等あれば是非教えてください) - Qiita

                                                        synchronizedの基本 プログラムにてスレッドを分けて処理しているけれど、複数スレッドに同時に処理を行わせてはいけない箇所(クリティカルセクション)があり、そこでは処理実行可能なスレッドを制限したいときなどに使う。 synchronizedと書けばいつも内部がシングルスレッド処理になるというものではないので、何のインスタンスを使って領域を守っているかをしっかり意識すること。 synchronizedメソッド synchronizedメソッドは、そのインスタンスにおいてsynchronized記述されているメソッドを実行できるスレッドを1つだけに制限するためのもの。 以下のクラスにおいて、someMethod()およびanotherMethod()はsynchronizedメソッドであり、このsomeClassインスタンスに対して複数のスレッドがsomeMethod()やanothe

                                                          Javaのsynchronizedの解説と典型的誤り集(記事の誤りや意見等あれば是非教えてください) - Qiita
                                                        • ミューテックスとアトミック処理について

                                                          主にアトミック処理に関する質問です。 いくつか不明な点があります。 アトミック処理とミューテックスの違いについて確認しておきます。 mutex と atomic の違いは何か、どちらが良いか アトミック操作 アトミック操作の長所は、ロックに比べて比較的処理が速く、デッドロックやコンボイなどを回避できる点にあります。 短所は、限られた操作しか行うことができず、より複雑な操作を効率良く総合的に扱うには不十分なことです。 次に、ロックフリーについて・・・ C++ストラウストラップ氏の本の中では以下のようにあります。 ロックフリープログラミングは明示的なロックを使わずに並行プログラムを開発するためのの一連の技法だ。 明示的なロックの代わりに使うのが、小規模オブジェクトに対するデータ競合を防ぐための(ハードウェアが直接サポートする)基礎的な演算である。データ競合が発生しない基礎的な演算は、一般的にア

                                                            ミューテックスとアトミック処理について
                                                          • C++ 高速化 OpenMP

                                                            top C++ 高速化 OpenMP 2018-07-21 - 2018-07-25 (update) mode save 高速化の解説一覧:[link:高速化] 処理を分担し並列計算させることで,時間のかかる処理も高速化できる場合があります.処理を並列化させたい場合,当然ながらコード上に並列化のための記述を加える必要があるのですが,OpenMPではシンプルな記述のみで並列化を実現できます. *OpenMP とは 並列化を行うための拡張言語です.CPUによる並列化を実行できます.{{small:GPUによる並列化は含みません.}} 対応言語:C/C++,Fortran 対応コンパイラ:gcc, Clang,Microsoft Visual C++,Intel Compiler(C++/Fortran) OpenMPの利用方法については,下記の資料が参考になります. {{small:[1]R

                                                            • 【C#】マルチスレッドプログラミングとは?メリット・デメリットを比較して効果を検証する - LIGHT11

                                                              マルチスレッドプログラミングの概要と、そのメリット・デメリットについて簡単にまとめます。 マルチスレッドプログラミングとは? 効果1 処理時間が短縮される 効果2 画面のフリーズを防ぐ マルチスレッドで処理してみる 効果があるのはあくまでCPUの処理 参考 関連 Unity2018.3.9 (C#の記事ですがUnityを使って動作確認しています) マルチスレッドプログラミングとは? まずマルチスレッドでないプログラムでは、1つのCPUコアで処理を先頭から順番に行っていきます。 CPUコアを一つしか持たないシングルコアのCPUではもちろん、 マルチコアのCPUにであっても一つのCPUだけを使って処理を行います。並列では行いません。 ここでマルチスレッドのプログラムを書くと、マルチコアCPUではスレッド毎に別のCPUコアで別の処理を行います。 シングルコアのCPUでは、一つのCPUコアで処理を

                                                                【C#】マルチスレッドプログラミングとは?メリット・デメリットを比較して効果を検証する - LIGHT11
                                                              • RunLoop.main vs DispatchQueue.main: The differences explained

                                                                RunLoop.main and DispatchQueue.main are often used as schedulers within Combine. During code reviews, I often encounter inconsistency in using one or another, which made me realize it’s not always clear what the differences are. You might be surprised by the outcome of this article! While you can use both RunLoop.main and DispatchQueue.main in different scenarios, I will focus on its usage within

                                                                  RunLoop.main vs DispatchQueue.main: The differences explained
                                                                • iOS Interview Questions and Answers for Senior Developers Part 1 - Swift

                                                                  iOS Interview Questions and Answers for Senior Developers Part 1 - Swift I recently got into the position of leading the technical interview when my client was searching for a new senior iOS developer. It's a challenging task to evaluate the skills and knowledge of another developer. So in this post, I want to share my results of the most useful iOS and Swift questions and answers with you. I cate

                                                                  • Parallel task error handling in Step Functions

                                                                    The Problem When you run concurrent tasks in step functions, either as a Parallel state or a Map state, you might want to wait until all tasks complete, regardless of whether they would succeed or fail. By default, Map or Parallel state will wait for all to succeed before ending or proceeding to the next state, however they will be terminated if a single iteration or branch has failed, and all oth

                                                                      Parallel task error handling in Step Functions
                                                                    • Concurrent programming, with examples

                                                                      Mention concurrency and you’re bound to get two kinds of unsolicited advice: first that it’s a nightmarish problem which will melt your brain, and second that there’s a magical programming language or niche paradigm which will make all your problems disappear. We won’t run to either extreme here. Instead we’ll cover the production workhorses for concurrent software – threading and locking – and le

                                                                        Concurrent programming, with examples
                                                                      • Anthony Accomazzo @ acco.io | I finally escaped Node (and you can too)

                                                                        I wrote my first Node program in 2013. (It was in CoffeeScript.) In those days, there were three factors contributing to Node's ascendancy: The first was "JavaScript everywhere." This originally meant "JavaScript on the front-end, JavaScript on the back-end," which always struck me as a weak rationale. (This has since evolved into "might is right" and JavaScript as a lingua franca, which is a bit

                                                                        • How HappyLock Works

                                                                          Recently, I released version 0.3 of my HappyLock crate on crates.io. In this blog post, I wanted to explain what I changed, and why it works. Background There are four conditions necessary for a deadlock to occur. You only need to prevent one of them in order to prevent all deadlocks: Mutual exclusion Non-preemptive allocation Circular wait Partial allocation Let's go through each one, and see wha

                                                                          • The Swift Programming Language: Redirect

                                                                            This content has moved; redirecting to the new location.

                                                                            • Some mistakes Rust doesn't catch

                                                                              Contents The size of the forest Fuck around now, find out... when? Also, types Losing the thread Off to the race conditions You can't use an old map to explore a new world But not all is preventable I still get excited about programming languages. But these days, it's not so much because of what they let me do, but rather what they don't let me do. Ultimately, what you can with a programming langu

                                                                                Some mistakes Rust doesn't catch
                                                                              • Chris's Wiki :: blog/programming/GoConcurrencyStillNotEasy

                                                                                Even in Go, concurrency is still not easy (with an example) Go is famous for making concurrency easy, through good language support for goroutines. Except what Go makes easy is only one level of concurrency, the nuts and bolts level of making your code do things concurrently and communicating back and forth through channels. Making it do the right things concurrently is still up to you, and unfort

                                                                                • Concurrency Patterns in Embedded Rust

                                                                                  How should you do concurrency in an embedded no_std application? There's no built-in support for time-sliced threads in core; that abstraction is only available in std (see std::thread). The latest stable release brought the async/await feature to no_std thanks to our compiler work. Should you always use that instead? Is cooperative scheduling appropriate for all kind of embedded applications? Wha

                                                                                    Concurrency Patterns in Embedded Rust

                                                                                  新着記事