並び順

ブックマーク数

期間指定

  • から
  • まで

161 - 200 件 / 582件

新着順 人気順

data-structureの検索結果161 - 200 件 / 582件

  • Emulating an iPod Touch 1G and iPhoneOS 1.0 using QEMU (Part I) | Martijn de Vos

    Around a year ago, I started working on emulating an iPod Touch 1G using the QEMU emulation software. After months of reverse engineering, figuring out the specifications of various hardware components, and countless debugging runs with GDB, I now have a functional emulation of an iPod Touch that includes display rendering and multitouch support. The emulated device runs the first firmware ever re

    • What We Got Right, What We Got Wrong

      This is my closing talk (video) from the GopherConAU conference in Sydney, given November 10, 2023, the 14th anniversary of Go being launched as an open source project. The text is interspersed with the slides used in the presentation. What We Got Right, What We Got Wrong INTRODUCTION Hello. Let me start by thanking Katie and Chewy for the giving me the honor of presenting the closing talk for the

        What We Got Right, What We Got Wrong
      • Logic programming in Rust

        use ascent::ascent; ascent! { relation edge(i32, i32); relation path(i32, i32); path(x, y) <-- edge(x, y); path(x, z) <-- edge(x, y), path(y, z); } fn main() { let mut prog = AscentProgram::default(); prog.edge = vec![(1, 2), (2, 3)]; prog.run(); println!("path: {:?}", prog.path); } Features Lattices Ascent supports computing fixed points of user-defined lattices. The lattice keyword defines a lat

        • How RocksDB works - Artem Krylysov

          Introduction # Over the past years, the adoption of RocksDB increased dramatically. It became a standard for embeddable key-value stores. Today RocksDB runs in production at Meta, Microsoft, Netflix, Uber. At Meta RocksDB serves as a storage engine for the MySQL deployment powering the distributed graph database. Big tech companies are not the only RocksDB users. Several startups were built around

          • Understanding Allocations in Go

            Cleaning up heap allocations in GoThis is the 18th article of the Eureka Advent Calendar 2020. Yesterday we had a post from Jun Ernesto Okumura on diversity in Spotify’s recommender systems. IntroductionThanks to efficient in-built memory management in the Go runtime, we’re generally able to prioritise correctness and maintainability in our programs without much consideration for the details of ho

              Understanding Allocations in Go
            • LLM Powered Autonomous Agents

              Date: June 23, 2023 | Estimated Reading Time: 31 min | Author: Lilian Weng Building agents with LLM (large language model) as its core controller is a cool concept. Several proof-of-concepts demos, such as AutoGPT, GPT-Engineer and BabyAGI, serve as inspiring examples. The potentiality of LLM extends beyond generating well-written copies, stories, essays and programs; it can be framed as a powerfu

              • Scheme in the browser: A Hoot of a tale -- Spritely Institute

                Scheme in the browser: A Hoot of a taleDave Thompson — October 10, 2023 Hey there, it’s been a while! We’re back to share some more exciting news about Guile Hoot, a WebAssembly toolchain and Scheme→WASM compiler. In our last post we demonstrated that the Guile Hoot toolchain can be used to assemble programs written in WebAssembly Text (WAT) format, which allowed us to develop for the WASM-4 fanta

                  Scheme in the browser: A Hoot of a tale -- Spritely Institute
                • pprof++: A Go Profiler with Hardware Performance Monitoring

                  You’re seeing information for Japan . To see local features and services for another location, select a different city. Show more Motivation for a Better Go Profiler Golang is the lifeblood of thousands of Uber’s back-end services, running on millions of CPU cores. Understanding our CPU bottlenecks is critical, both for reducing service latencies and also for making our compute fleet efficient. Th

                    pprof++: A Go Profiler with Hardware Performance Monitoring
                  • Understanding the Heap - a beautiful mess

                    In this blog, I am going to explain the important concepts of Heap and use the ptmalloc in the Glibc 2.31 library as an example. The heap is a beautiful mess :) I really like the saying shown above. The word Heap we always use refers to the dynamically allocated segment in the virtual memory space of a process, but it actually stands for the implementation of the memory pool(the dynamic memory all

                    • Why Authorization is Hard

                      Feb 2023 Update: Since writing this post in 2021, we've built, released, and GA-ed Oso Cloud: our opinionated solution for authorization. Two years ago, my cofounder and I started building security tools for infrastructure. We kept hearing that application developers were building their own homegrown authorization tools. At first we were a little skeptical. People have been building authorization

                        Why Authorization is Hard
                      • Writing a scheduler for Linux in Rust that runs in user-space

                        Overview I’ve decided to start a series of blog posts to cover some details about scx_rustland, my little Linux scheduler written in Rust that runs in user-space. This project started for fun over the Christmas break, mostly because I wanted to learn more about sched-ext and I also needed some motivation to keep practicing Rust (that I’m still learning). In this series of articles I would like to

                        • TypedDicts are better than you think

                          TypedDict was introduced in PEP-589 which landed in Python 3.8. The primary use case was to create type annotations for dictionaries. For example, class Movie(TypedDict): title: str movie: Movie = {"title": "Avatar"} I remember thinking at the time that this was pretty neat, but I tend to use dataclass or pydantic to represent 'record' type data. Instead I use dictionaries more as a collection, so

                          • 🎉 Happy 10th Birthday, Sidekiq! 🎂

                            2022-01-17 It’s hard for me to believe these words but I pushed Sidekiq’s first commit on Jan 16th, 2012. Ten years ago. The public announcement. One month later. One quarter later. Some context for those new to this blog: Sidekiq is the most popular background job system for the Ruby programming language. Every application has tasks which are important: send an email, charge a credit card, reserv

                            • Rewriting Recoil from scratch

                              Published September 9, 2020 - (Updated October 5, 2022) Recoil is a slick new React library written by some people at Facebook that work on a tool called "Comparison View." It came about because of ergonomics and performance issues with context and useState. It's a very clever library, and almost everyone will find a use for it - check out this explainer video if you want to learn more. At first I

                                Rewriting Recoil from scratch
                              • From where I left - <antirez>

                                antirez 8 days ago. 256174 views. I’m not the kind of person that develops a strong attachment to their own work. When I decided to leave Redis, about 1620 days ago (~ 4.44 years), I never looked at the source code, commit messages, or anything related to Redis again. From time to time, when I needed Redis, I just downloaded it and compiled it. I just typed “make” and I was very happy to see that,

                                • Monads and GATs in nightly Rust

                                  This blog post was entirely inspired by reading the GATs on Nightly! Reddit post by /u/C5H5N5O. I just decided to take things a little bit too far, and thought a blog post on it would be fun. I want to be clear from the start: I'm introducing some advanced concepts in this post that rely on unstable features in Rust. I'm not advocating their usage at all. I'm just exploring what may and may not be

                                    Monads and GATs in nightly Rust
                                  • 1億DAUの中華ゲームを支えるアーキテクチャ - Qiita

                                    前書き 「AWS & Game Advent Calendar 2020」二日目の記事になります。 近年日本では、アズールレーン、荒野行動、原神など中国制のゲームが多く進出されています。 最近では、「原神1ヶ月間251億円を稼いだ」や「王者栄耀のDAUが1億を超えた」などニュースにもなっています。 私は中国出身のため、この1年の仕事中でも、関連の内容が聞かれたことは何回かありました。今回のAdvent Calendarをきっかけに、王者栄耀や荒野行動をはじめ、典型的な中華ゲームのアーキテクチャと日本のゲームの違いについて、説明したいと思います。 最後、AWS&Gameのカレンダーですが、ゲーム自体はAWSで動いていることとイコールになりません。実際この記事で触れたゲームの中、荒野行動のグローバルとアーチャー伝説だけがAWSの公開事例になります。また、この投稿は、個人の意見であり、所属する企

                                      1億DAUの中華ゲームを支えるアーキテクチャ - Qiita
                                    • Category Theory Illustrated - Sets

                                      Sets Let’s begin our inquiry by looking at the basic theory of sets. Set theory and category theory share many similarities. We can view category theory as a generalization of set theory. That is, it’s meant to describe the same thing as set theory (everything?), but to do it in a more abstract manner, one that is more versatile and (hopefully) simpler. In other words, sets are an example of a cat

                                      • 0.10.0 Release Notes ⚡ The Zig Programming Language

                                        Tier 4 Support § Support for these targets is entirely experimental. If this target is provided by LLVM, LLVM may have the target as an experimental target, which means that you need to use Zig-provided binaries for the target to be available, or build LLVM from source with special configure flags. zig targets will display the target if it is available. This target may be considered deprecated by

                                        • A Proposal for Adding Generics to Go - The Go Programming Language

                                          Ian Lance Taylor 12 January 2021 Generics proposal We’ve filed a Go language change proposal to add support for type parameters for types and functions, permitting a form of generic programming. Why generics? Generics can give us powerful building blocks that let us share code and build programs more easily. Generic programming means writing functions and data structures where some types are left

                                            A Proposal for Adding Generics to Go - The Go Programming Language
                                          • Go Modules Reference - The Go Programming Language

                                            Introduction Modules are how Go manages dependencies. This document is a detailed reference manual for Go’s module system. For an introduction to creating Go projects, see How to Write Go Code. For information on using modules, migrating projects to modules, and other topics, see the blog series starting with Using Go Modules. Modules, packages, and versions A module is a collection of packages th

                                              Go Modules Reference - The Go Programming Language
                                            • An Interactive Intro to CRDTs | jakelazaroff.com

                                              Have you heard about CRDTs and wondered what they are? Maybe you’ve looked into them a bit, but ran into a wall of academic papers and math jargon? That was me before I started my Recurse Center The Recurse Center The Recurse Center is a self-directed, community-driven educational retreat for programmers in New York City. www.recurse.com/ batch. But I’ve spent the past month or so doing research a

                                                An Interactive Intro to CRDTs | jakelazaroff.com
                                              • Write a time-series database engine from scratch

                                                Write a time-series database engine from scratch July 1, 2021 This blog post walks you through how to implement a time-series database engine based on what I’ve learned from my experience of writing a lightweight one from scratch. While it is written in Go, it mostly covers language-agnostic. Motivation I’ve been working on a couple of tools that handle a tremendous amount of time-series data. One

                                                  Write a time-series database engine from scratch
                                                • Kafka Without ZooKeeper: A Sneak Peek At the Simplest Kafka Yet

                                                  At the heart of Apache Kafka® sits the log—a simple data structure that uses sequential operations that work symbiotically with the underlying hardware. Efficient disk buffering and CPU cache usage, prefetch, zero-copy data transfers, and many other benefits arise from the log-centric design, leading to the high efficiency and throughput that it is known for. For those new to Kafka, the topic—and

                                                    Kafka Without ZooKeeper: A Sneak Peek At the Simplest Kafka Yet
                                                  • Wasmtime 1.0: A Look at Performance

                                                    In preparation for our upcoming release of Wasmtime 1.0 on September 20, we have prepared two blog posts describing the work we have put into the compiler and runtime recently. This first post will describe performance-related projects: making the compiler generate faster code, making the compiler itself run faster, making Wasmtime instantiate a compiled module faster, and making Wasmtime’s runtim

                                                      Wasmtime 1.0: A Look at Performance
                                                    • Unimog - Cloudflare’s edge load balancer

                                                      As the scale of Cloudflare’s edge network has grown, we sometimes reach the limits of parts of our architecture. About two years ago we realized that our existing solution for spreading load within our data centers could no longer meet our needs. We embarked on a project to deploy a Layer 4 Load Balancer, internally called Unimog, to improve the reliability and operational efficiency of our edge n

                                                        Unimog - Cloudflare’s edge load balancer
                                                      • Assorted thoughts on zig (and rust)

                                                        I've been using zig for ~4 months worth of side projects, including a toy text editor and an interpreter for a relational language. I've written ~10kloc. That's not nearly enough time to form a coherent informed opinion. So instead here is an incoherent assortment of thoughts and experiences, in no particular order :) This is not meant to be an introduction to zig - check out the excellent languag

                                                        • Cloudflare functions with Scala.js

                                                          Indoor VivantsAnton Sviridov. I love reinventing the wheel and I usually use Scala for that. TL;DR We are deploying an app to Cloudflare using Scala.js We are using ScalablyTyped We are using Scala 3 heavily Code on Github Deployed app Cloudflare API bindings Welcome to the "Put ma Scala on yo cloud" series I want to say that I'm kicking off a blog series, but even I don't believe that. If I did,

                                                          • High Assurance Rust

                                                            This book is an introduction to building performant software we can justifiably trust. That means having sufficient data to support confidence in our code's functionality and security. Trustworthiness is a hallmark of high assurance software. With assurance as our driving concept, we'll take a hands-on, project-based approach to two fundamental but often inaccessible topics in software development

                                                              High Assurance Rust
                                                            • Rearchitecting: Redis to SQLite | Wafris

                                                              Pssst - want to skip right to the chart? click here Background We're Wafris, an open-source web application firewall company that, among other frameworks, ships a Rails middleware client. At launch, the v1 client required a local Redis datastore to be deployed with your app. We're now releasing v2 of our Rails client which uses SQLite as the backing datastore. This article covers the decision-maki

                                                              • 10 Tips for Building Resilient Payment Systems - Shopify

                                                                10 Tips for Building Resilient Payment SystemsThe top 10 tips and tricks for building resilient payment systems from a Staff Developer working on Shopify’s payment infrastructure. During the past five years I’ve worked on a lot of different parts of Shopify’s payment infrastructure and helped onboard dozens of developers in one way or another. Some people came from different programming languages,

                                                                  10 Tips for Building Resilient Payment Systems - Shopify
                                                                • Bloom Filters

                                                                  This page makes heavy use of JavaScript to visualise the concepts discussed. Viewing it without JavaScript will be a strange experience, as the text talks about the visualisations. I strongly recommend either enabling JavaScript, or not wasting your time. Everyone has a set of tools they use to solve problems. Growing this set helps you to solve ever more difficult problems. In this post, I'm goin

                                                                    Bloom Filters
                                                                  • Accelerate Python code 100x by import taichi as ti | Taichi Docs

                                                                    Python has become the most popular language in many rapidly evolving sectors, such as deep learning and data sciences. Yet its easy readability comes at the cost of performance. Of course, we all complain about program performance from time to time, and Python should certainly not take all the blame. Still, it's fair to say that Python's nature as an interpreted language does not help, especially

                                                                    • SOSP21 で best paper 賞を受賞した S3 の論文を読んでみる - ablog

                                                                      SOSP21 で best paper 賞を受賞した S3 の論文 "Using Lightweight Formal Methods to Validate a Key-Value Storage Node in Amazon S3" を読んでみる。 Abstract This paper reports our experience applying lightweight formal methods to validate the correctness of ShardStore, a new key-value storage node implementation for the Amazon S3 cloud object storage service. By “lightweight formal methods" we mean a pragmatic approac

                                                                        SOSP21 で best paper 賞を受賞した S3 の論文を読んでみる - ablog
                                                                      • CXX — safe interop between Rust and C++

                                                                        CXX — safe interop between Rust and C++ This library provides a safe mechanism for calling C++ code from Rust and Rust code from C++. It carves out a regime of commonality where Rust and C++ are semantically very similar and guides the programmer to express their language boundary effectively within this regime. CXX fills in the low level stuff so that you get a safe binding, preventing the pitfal

                                                                          CXX — safe interop between Rust and C++
                                                                        • GitHub - cessen/ropey: A utf8 text rope for manipulating and editing large texts.

                                                                          // Load a text file. let mut text = ropey::Rope::from_reader( File::open("my_great_book.txt")? )?; // Print the 516th line (zero-indexed). println!("{}", text.line(515)); // Get the start/end char indices of the line. let start_idx = text.line_to_char(515); let end_idx = text.line_to_char(516); // Remove the line... text.remove(start_idx..end_idx); // ...and replace it with something better. text.

                                                                            GitHub - cessen/ropey: A utf8 text rope for manipulating and editing large texts.
                                                                          • Writing an open source GPU driver - without the hardware

                                                                            After six months of reverse-engineering, the new Arm “Valhall” GPUs (Mali-G57, Mali-G78) are getting free and open source Panfrost drivers. With a new compiler, driver patches, and some kernel hacking, these new GPUs are almost ready for upstream. In 2021, there were no Valhall devices running mainline Linux. While a lack of devices poses an obvious obstacle to device driver development, there is

                                                                              Writing an open source GPU driver - without the hardware
                                                                            • The visitor pattern is essentially the same thing as Church encoding

                                                                              The visitor pattern is essentially the same thing as Church encoding This post explains how the visitor pattern is essentially the same thing as Church encoding (or Böhm-Berarducci encoding). This post also explains how you can usefully employ the visitor pattern / Church encoding / Böhm-Berarducci encoding to expand your programming toolbox. Background Church encoding is named after Alonzo Church

                                                                              • pg_crdt - an experimental CRDT extension for Postgres

                                                                                Today we're open-sourcing an EXPERIMENTAL extension for CRDTs, pg_crdt. The GitHub repo is here. There are instructions for running it locally in the README. When we released the new multiplayer features for our Realtime engine, it took 30 minutes for someone to ask if we'd add CRDT support. Anyone from Supabase here, do you have any plans to build in support for CRDT toolkits such as Yjs or AutoM

                                                                                  pg_crdt - an experimental CRDT extension for Postgres
                                                                                • What’s The Deal With Ractors?

                                                                                  I want to write a post about Pitchfork, explaining where it comes from, why it is like it is, and how I see its future. But before I can get to that, I think I need to share my mental model on a few things, in this case, Ractors. When Ractors were announced 4 or 5 years ago, many people expected we’d quickly see a Ractor-based web server, some sort of Puma but with Ractors instead of threads. Yet