並び順

ブックマーク数

期間指定

  • から
  • まで

1 - 39 件 / 39件

新着順 人気順

concurrentの検索結果1 - 39 件 / 39件

  • SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ

    SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ SQLiteの開発チームは、複数クライアントからの同時書き込みを可能にするBEGIN CONCURRENT文を実装していることを明らかにしました。 これまでSQLiteでは書き込みの同時実行はできず、つねに1つのクライアントだけが書き込み可能でした。 同時書き込み処理は、データベースのジャーナルモードが「wal」(Write-Ahead-log)もしくはwalを改良した「wal2」で、BEGIN CONCURRENT文を実行した場合に可能となります。 どのように同時書き込み処理が行われるのかについては、上記のWebページの説明を引用しましょう。 ロックが延期されることで同時書き込みが可能に まず、書き込み時のロックがCOMMITまで延期されることで同時書き込みが実現されると説明されて

      SQLite、複数クライアントからの同時書き込みを可能にする「BEGIN CONCURRENT」文を実装へ
    • Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 - Qiita

      Concurrent Modeは、現在(2020年3月)実験的機能として公開されているReactの新しいバージョンです。Reactの次のメジャーバージョン(17.x)で正式リリースされるのではないかと思っていますが、確証はありません。なお、React公式からもすでに結構詳細なドキュメントが出ています。 並列モードの導入(実験的機能) Concurrent Modeに適応したアプリケーションを作るためには、従来とは異なる新しい設計が必要となります。筆者はConcurrent Modeを使ったアプリケーションをひとつ試作してみました。この記事から始まる「Concurrent Mode時代のReact設計論」シリーズでは、ここから得た知見を共有しつつ、Concurrent Mode時代に適応したReactアプリケーションの設計を提案します。 なお、Concurrent Modeはまだ正式リリース

        Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 - Qiita
      • Introducing Concurrent Mode (Experimental) – React

        Caution: This page is somewhat outdated and only exists for historical purposes. React 18 was released with support for concurrency. However, there is no “mode” anymore, and the new behavior is fully opt-in and only enabled when you use the new features. For up-to-date high-level information, refer to: React 18 Announcement Upgrading to React 18 React Conf 2021 Videos For details about concurrent

          Introducing Concurrent Mode (Experimental) – React
        • GitHub - microsoft/verona: Research programming language for concurrent ownership

          Project Verona is a research programming language to explore the concept of concurrent ownership. We are providing a new concurrency model that seamlessly integrates ownership. This research project is at an early stage and is open sourced to facilitate academic collaborations. We are keen to engage in research collaborations on this project, please do reach out to discuss this. The project is not

            GitHub - microsoft/verona: Research programming language for concurrent ownership
          • SQLite performance tuning - Scaling SQLite databases to many concurrent readers and multiple gigabytes while maintaining 100k SELECTs per second - phiresky's blog

            SQLite performance tuningScaling SQLite databases to many concurrent readers and multiple gigabytes while maintaining 100k SELECTs per second Jun 26, 2020 • Last Update Jul 31, 2022SQLite is an embedded SQL database. It’s extremely easy to setup, buildable as a single C file with libraries existing for basically all common programming languages. It doesn’t need any server setup or configuration si

            • React Concurrent Mode の概要をおさえる - うどん よこみち

              はじめに この記事は, Introducing Concurrent Mode (Experimental) – React を,和訳しつつ自分の解釈や図を少しだけ足したものになります. 筆者は,そこまで英語が得意ではないので,一部適切でない表現があるかもしれませんがご了承ください. Introducing Concurrent Mode (Experimental) Blocking vs Interruptible Rendering Concurrent Mode は,バージョンコントロール を使って説明します. ここで言うバージョン管理というのは,gitのようなバージョン管理システムです. ブランチを切って作業を行い,他の人が pull できるように作業ブランチをマスターにマージします. バージョン管理の概念が存在する前と後では,開発ワークフローは大きく異なっていました. ブランチ

                React Concurrent Mode の概要をおさえる - うどん よこみち
              • React Concurrent Mode雑感 - しゅみは人間の分析です

                Concurrent Modeのドキュメントを読みました。useEffect によるFetch-on-render から、Suspense によるRender-as-You-Fetch への変化が本質にみえます。 before function ProfilePage() { const [user, setUser] = useState(null); useEffect(() => { fetchUser().then(u => setUser(u)); }, []); if (user === null) { return <p>Loading profile...</p>; } return ( <> <h1>{user.name}</h1> <ProfileTimeline /> </> ); } function ProfileTimeline() { // 省略 } afte

                  React Concurrent Mode雑感 - しゅみは人間の分析です
                • GitHub - dai-shi/will-this-react-global-state-work-in-concurrent-rendering: Test tearing and branching in React concurrent rendering

                  With useTransition Level 1 ✓ No tearing finally on update (7990 ms) ✓ No tearing finally on mount (4608 ms) Level 2 ✓ No tearing temporarily on update (12955 ms) ✓ No tearing temporarily on mount (4546 ms) Level 3 ✕ Can interrupt render (time slicing) (7926 ms) ✕ Can branch state (wip state) (6655 ms) With useDeferredValue Level 1 ✓ No tearing finally on update (9568 ms) ✓ No tearing finally on mo

                    GitHub - dai-shi/will-this-react-global-state-work-in-concurrent-rendering: Test tearing and branching in React concurrent rendering
                  • Amazon increases NAT Gateway’s capacity to support concurrent connections to a unique destination

                    Starting today, you can configure your NAT Gateway to support up to 440,000 concurrent connections to a unique destination by adding multiple IP addresses to same NAT Gateway. A NAT Gateway enables instances in a private subnet to connect to services outside the subnet using the IP address associated with the NAT Gateway. Prior to this launch, you could associate one IP address to your NAT Gateway

                      Amazon increases NAT Gateway’s capacity to support concurrent connections to a unique destination
                    • How Much Memory Do You Need to Run 1 Million Concurrent Tasks? | Piotr Kołaczkowski

                      In this blog post, I delve into the comparison of memory consumption between asynchronous and multi-threaded programming across popular languages like Rust, Go, Java, C#, Python, Node.js and Elixir. Some time ago I had to compare performance of a few computer programs designed to handle a large number of network connections. I saw huge differences in memory consumption of those programs, even exce

                      • Concurrent and Parallel Programming - <h1>Joe Armstrong - Erlang and other stuff</h1>

                        • GitHub - pen-lang/pen: The parallel, concurrent, and functional programming language for scalable software development

                          Pen is the parallel, concurrent, and functional programming language focused on application programming following Go's philosophy. It aims for further simplicity, testability, and portability to empower team (v. individual) and/or long-term (v. short-term) productivity. Its syntax, type system, effect system, and module system are fashioned to achieve those goals being simple and easy to grasp for

                            GitHub - pen-lang/pen: The parallel, concurrent, and functional programming language for scalable software development
                          • Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% - Phoronix

                            Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% Written by Michael Larabel in Linux Networking on 9 January 2024 at 02:23 PM EST. 76 Comments Beyond the usual new wired/wireless network hardware support and the other routine churn in the big Linux networking subsystem, the Linux 6.8 kernel is bringing some key improvements to the core networking co

                              Linux 6.8 Network Optimizations Can Boost TCP Performance For Many Concurrent Connections By ~40% - Phoronix
                            • How to Perform Concurrent HTTP Requests in Ruby on Rails

                              Sponsored by pganalyze Deliver consistent Postgres performance and availability through intelligent tuning advisors and continuous database profiling. Ruby MRI does not support parallel CPU bound operations due to the dependency on non-thread safe C extensions. Input/Output operations like HTTP requests, are still a perfectly valid use case for spinning up multiple threads. Read on to learn what t

                                How to Perform Concurrent HTTP Requests in Ruby on Rails
                              • React の Concurrent Mode を使ってみる(2020年12月版) - 30歳からのプログラミング

                                React で開発が進められている Concurrent Mode。 まだリリース前の開発中の機能だが、「実験的機能」として提供されており、Experimentalビルドをインストールすることで利用できる。 Experimentalはリリース間の安定性を何も保証しておらず、破壊的変更が行われる可能性がある。Concurrent Mode の動作も、大きく変わる可能性がある。 記事のタイトルに「2020年12月版」と入れたのは、そのため。 公式ドキュメントでは「並列モード」と翻訳されているが、まさに、並列的にレンダリングを行えるようになる。 ネットワークからデータを取得して要素をレンダリングする際に、ユーザーに見えないところで新しいレンダリングの準備をしつつ、データが取得できるまでは古いレンダリングを表示しておく、といったことが可能になる。 この記事では、どういった仕組みでそのようなことが可

                                  React の Concurrent Mode を使ってみる(2020年12月版) - 30歳からのプログラミング
                                • A lock-free, concurrent, generic queue in 32 bits

                                  This article was discussed on Hacker News. While considering concurrent queue design I came up with a generic, lock-free queue that fits in a 32-bit integer. The queue is “generic” in that a single implementation supports elements of any arbitrary type, despite an implementation in C. It’s lock-free in that there is guaranteed system-wide progress. It can store up to 32,767 elements at a time — mo

                                  • GitHub - ms-jpq/coq_nvim: Fast as FUCK nvim completion. SQLite, concurrent scheduler, hundreds of hours of optimization.

                                    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

                                      GitHub - ms-jpq/coq_nvim: Fast as FUCK nvim completion. SQLite, concurrent scheduler, hundreds of hours of optimization.
                                    • Building Great User Experiences with Concurrent Mode and Suspense – React Blog

                                      At React Conf 2019 we announced an experimental release of React that supports Concurrent Mode and Suspense. In this post we’ll introduce best practices for using them that we’ve identified through the process of building the new facebook.com. This post will be most relevant to people working on data fetching libraries for React. It shows how to best integrate them with Concurrent Mode and Suspens

                                        Building Great User Experiences with Concurrent Mode and Suspense – React Blog
                                      • GitHub - xacrimon/dashmap: Blazing fast concurrent HashMap for Rust.

                                        Blazingly fast concurrent map in Rust. DashMap is an implementation of a concurrent associative array/hashmap in Rust. DashMap tries to implement an easy to use API similar to std::collections::HashMap with some slight changes to handle concurrency. DashMap tries to be very simple to use and to be a direct replacement for RwLock<HashMap<K, V>>. To accomplish these goals, all methods take &self ins

                                          GitHub - xacrimon/dashmap: Blazing fast concurrent HashMap for Rust.
                                        • Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する - Qiita

                                          この記事は「Concurrent Mode時代のReact設計論」シリーズの5番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                            Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する - Qiita
                                          • Migrating Millions of Concurrent Websockets to Envoy - Slack Engineering

                                            Ariane van der Steldt Staff Software Engineer, Site Reliability Slack has a global customer base, with millions of simultaneously connected users at peak times. Most of the communication between users involves sending lots of tiny messages to each other. For much of Slack’s history, we’ve used HAProxy as a load balancer for all incoming traffic. Today, we’ll talk about problems we faced with HAPro

                                              Migrating Millions of Concurrent Websockets to Envoy - Slack Engineering
                                            • Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 - Qiita

                                              この記事は「Concurrent Mode時代のReact設計論」シリーズの6番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                                Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 - Qiita
                                              • How I developed a Concurrent Mode friendly library for React Redux

                                                How I developed a Concurrent Mode friendly library for React Redux Introduction I have been developing several React hooks libraries for months. In this post, I will explain why and how I developed a React Redux binding library with React hooks. The library is implemented to be concurrent mode friendly. Let’s discuss why it’s important and what’s the technique behind it. React concurrent mode has

                                                  How I developed a Concurrent Mode friendly library for React Redux
                                                • Concurrent, Suspenseの文脈でキャッシュ管理と理想的なデータフェッチを考える (Recoil, Aspida, React Query, GraphQL)

                                                  データフェッチで考えられるシナリオ パラメータ無しのGET パラメータ有りのGET キャッシュ保持 キャッシュのinvalidate キャッシュしたデータに対するモデリング ReduxでいうcreateEntityAdapter的な プリフェッチ(+並行リクエスト) SSR対応 APIコールを行わずに初期値を渡せる 最大要件とインタフェースはReact Queryを参考にする すごいオプションあるけど実際に作ってて欲しくなるのは以下 onStart onEnd onSuccess onError refetchOnMount( or staleTime) また、ユーザー体験の観点で以下の要件を満たせると良い 楽観的UI Suspendせずにリフェッチ可能 (画面のチラつき防止) こうして考えたときにReact Queryはほぼ全ての要求を満たしていてさすがだと思う。 キャッシュも効くのでR

                                                    Concurrent, Suspenseの文脈でキャッシュ管理と理想的なデータフェッチを考える (Recoil, Aspida, React Query, GraphQL)
                                                  • How we tripled max concurrent jobs to boost performance of GitHub Actions

                                                    EngineeringHow we tripled max concurrent jobs to boost performance of GitHub ActionsThe GitHub Actions team has done lots of work to improve the performance and resource consumption of Actions on GHES in the past year. GitHub Actions became generally available on GitHub Enterprise Server (GHES) with the 3.0 release about two years ago. Since then, we’ve made many performance improvements to the pr

                                                      How we tripled max concurrent jobs to boost performance of GitHub Actions
                                                    • 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
                                                      • GitHub - bryanp/goru: Concurrent routines for 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

                                                          GitHub - bryanp/goru: Concurrent routines for Ruby.
                                                        • PythonのThread(並列処理)は速度改善効果がないので「concurrent.futures」を使う - SE_BOKUのまとめノート的ブログ

                                                          目次 PythonのThread(並列処理)は速度改善効果がないのか確認 シーケンシャル実行ケースの計測 PythonのThreadを使うケースの時間計測 Threadで速度改善しないのがPythonの仕様 Pythonの並列処理で速度向上できる方法と計測結果 PythonのThread(並列処理)は速度改善効果がないのか確認 PythonのThreadで並列性による速度改善効果を期待しても無駄だと教えてもらったので試してみました。 同じ重たい処理をシーケンシャルに実行するのと、PythonのThreadを使って並列処理するので、どのくらい速度があがるのか?を確認してみます。 シーケンシャル実行ケースの計測 シーケンシャルの処理です。 import time # 単に時間がかかるだけの処理 def killing_time(number): return_list = [] for i i

                                                            PythonのThread(並列処理)は速度改善効果がないので「concurrent.futures」を使う - SE_BOKUのまとめノート的ブログ
                                                          • ConcurrentとParallel

                                                            はじめにO’Reilly Japan - Go言語による並行処理 を読んでいると、気になるフレーズが出てきました。 「並行性はコードの性質を指し、並列性は動作しているプログラムの性質を指します。」 「そうなの?」と思い某所で呟いてみると、色々情報が集まったのでまとめます。 Go言語におけるConcurrent/Parallelの解釈最初に、「並行性はコードの性質を指し、並列性は動作しているプログラムの性質を指します。」のについて。 原文では Concurrency is a property of the code; parallelism is a property of the running program. となっているようです。(参照: O’Reilly Concurrency in Goの読書メモ - Qiita) また、Go言語に関する書籍である背景を鑑みると、Rob Pik

                                                              ConcurrentとParallel
                                                            • GitHub - frejs/fre: :ghost: Tiny Concurrent UI library with Fiber.

                                                              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

                                                                GitHub - frejs/fre: :ghost: Tiny Concurrent UI library with Fiber.
                                                              • SQLite Concurrent Access

                                                                Does SQLite3 safely handle concurrent access by multiple processes reading/writing from the same DB? Are there any platform exceptions to that?

                                                                  SQLite Concurrent Access
                                                                • GitHub - zio/zio: ZIO — A type-safe, composable library for async and concurrent programming in Scala

                                                                  ZIO is a zero-dependency Scala library for asynchronous and concurrent programming. Powered by highly-scalable, non-blocking fibers that never waste or leak resources, ZIO lets you build scalable, resilient, and reactive applications that meet the needs of your business. High-performance. Build scalable applications with minimal runtime overhead. Type-safe. Use the full power of the Scala compiler

                                                                    GitHub - zio/zio: ZIO — A type-safe, composable library for async and concurrent programming in Scala
                                                                  • Concurrent Mode時代のReact設計論 (2) useTransitionを活用する - Qiita

                                                                    この記事は「Concurrent Mode時代のReact設計論」シリーズの2番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジションを軸に設計する Concurrent Mode時代のReact設計論 (6) Concurrent Modeと副作用 Concurrent Mode時代のReact設計論 (

                                                                      Concurrent Mode時代のReact設計論 (2) useTransitionを活用する - Qiita
                                                                    • Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか - Qiita

                                                                      Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するかJavaScriptTypeScriptReact この記事は「Concurrent Mode時代のReact設計論」シリーズの3番目の記事です。 シリーズ一覧 Concurrent Mode時代のReact設計論 (1) Concurrent Modeにおける非同期処理 Concurrent Mode時代のReact設計論 (2) useTransitionを活用する Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか Concurrent Mode時代のReact設計論 (4) コンポーネント設計にサスペンドを組み込む Concurrent Mode時代のReact設計論 (5) トランジション

                                                                        Concurrent Mode時代のReact設計論 (3) SuspenseやuseTransitionが何を解決するか - Qiita
                                                                      • 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
                                                                        • IT生涯学習Tech Javaプログラム concurrentパッケージのExecutors

                                                                          concurrentパッケージ concurrentパッケージは、マルチスレッド処理において、各スレッドの状態の監視や管理をし易くした大変便利なパッケージです。 concurrentパッケージは、Java5より導入されたパッケージのため、Java5以降で利用可能です。 2017時点Javaプラットフォームを利用した多くのシステムでは、マルチスレッドと言えばconcurrentパッケージと言えます。 concurrentパッケージでは、大きく分けて次の概念で構成されています。 Thread及びrunnableのrunで実装していた主処理をタスクと呼びます。 タスクは、Executorインターフェイスを頂点とした各種サービス(ThreadPoolExecutor,ScheduledThreadPoolExecutorなど)に処理を並列処理を委譲します。 各種サービスは、サービスに依頼されたタス

                                                                            IT生涯学習Tech Javaプログラム concurrentパッケージのExecutors
                                                                          • SQLite: Begin Concurrent

                                                                            Overview Usually, SQLite allows at most one writer to proceed concurrently. The BEGIN CONCURRENT enhancement allows multiple writers to process write transactions simultanously if the database is in "wal" or "wal2" mode, although the system still serializes COMMIT commands. When a write-transaction is opened with "BEGIN CONCURRENT", actually locking the database is deferred until a COMMIT is execu

                                                                            • GitHub - eihigh/goban: goban - minimal and concurrent CUI

                                                                              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.

                                                                                GitHub - eihigh/goban: goban - minimal and concurrent CUI
                                                                              • Next.js でConcurrent Rendering(Suspense)を試してみた | DevelopersIO

                                                                                はじめに 現在(2022年1月14日)ではReact18のConcurrent RenderingはExperimentalな機能なので、リリースされるころには変わっている可能性がありますが、素振りやコンセプトは体験しておこうと思いまして、GitHubのユーザ検索を作ってみることにしました React18のConcurrent Renderingの概要はこちらを参考にしました。大変わかりやすい説明で感謝です。 ReactのSuspense対応非同期処理を手書きするハンズオン 公式はこちらになります サスペンスを使ったデータ取得(実験的機能) – React サンプルを簡単につくるために、Next.jsを使っています。素のReactでも良いんですが、Routerやらビルド周りを設定するのが面倒なので今回はNext.jsで作ります。 手順 Next.jsのTypeScriptでのプロジェクトを

                                                                                  Next.js でConcurrent Rendering(Suspense)を試してみた | DevelopersIO
                                                                                1