並び順

ブックマーク数

期間指定

  • から
  • まで

1 - 34 件 / 34件

新着順 人気順

internalsの検索結果1 - 34 件 / 34件

  • ソルト付きハッシュのソルトはどこに保存するのが一般的か - Qiita

    pictBLandとpictSQUAREに対する不正アクセスがあり、パスワードがソルトなしのMD5ハッシュで保存されていたことが話題になっています。 2023年8月16日に外部のフォーラムにpictSQUAREより窃取した情報と主張するデータ販売の取引を持ち掛ける投稿が行われた(中略)パスワードはMD5によるハッシュ化は行われているもののソルト付与は行われていなかったため、単純なパスワードが使用されていた29万4512件は元の文字列が判明していると投稿。(それ以外の26万8172件はまだMD5ハッシュ化されたままと説明。) 不正アクセスによるpictBLand、pictSQUAREの情報流出の可能性についてまとめてみた - piyolog より引用 これに関連してMD5ハッシュやソルトに関するツイート(post)を観察したところ、どうもソルトの理解が間違っている方が多いような気がしました。

      ソルト付きハッシュのソルトはどこに保存するのが一般的か - Qiita
    • git gc の仕組みを原理から理解してサイズを 136MB → 7.2MB(95%減)まで削減した時の勉強メモ

      個人用メモです。 「git gcってあんまし容量減らないよなぁ」 と思ったのが動機です。調べたけどパッと腑に落ちる記事がなかったので「自分で git のソースコード見た方がいいな」と急にモチベ発動してグワっと勉強しました。またついでに歴史改変の方法も調べたのですが、公式で既に WARNING が出てるほど非推奨化されてるfilter-branchを使用してる記事が多かったので、2021 年現在で多分一番推奨されてるfilter-repoを使ってやる方法もまとめました。 ちなみに容量減らしても高速化するかというとそこまで単純ではないです。そもそも減らさなくても partial clone で blob オブジェクトを必要最低限に指定して昔の blob をデフォルトで持ってこないようにしたり(--no-checkoutと併用するとより効果有る)、その後本当に自分が必要なやつだけ sparse-

        git gc の仕組みを原理から理解してサイズを 136MB → 7.2MB(95%減)まで削減した時の勉強メモ
      • Redis Explained

        Redis Explained InfographicWhat is Redis?Redis (“REmote DIctionary Service”) is an open-source key-value database server. The most accurate description of Redis is that it's a data structure server. This specific nature of Redis has led to much of its popularity and adoption amongst developers. 👋🏾You are reading Architecture Notes! Crave some byte-sized bites of this? Join me on Twitter. If it's

          Redis Explained
        • SQLite Internals: Pages & B-trees

          SQLite Internals: Pages & B-trees Author Name Ben Johnson @benbjohnson @benbjohnson Image by Annie Ruygt Fly.io runs apps close to users around the world, by taking containers and upgrading them to full-fledged virtual machines running on our own hardware around the world. Sometimes those containers run SQLite and we make that easy too. Give us a whirl and get up and running quickly. Ok, I’ll admi

            SQLite Internals: Pages & B-trees
          • Exploring Notion's Data Model: A Block-Based Architecture | Notion

            A generation of pioneers (Doug Engelbart, Ted Nelson, Alan Kay, and many more) saw the computer as tool to augment human problem-solving by giving people power over information. Today, that information mostly remains siloed across tools. Take cloud-based document editors, where pages are their smallest atomic unit. Information is locked inside of pages and files and folders — that’s reminiscent of

              Exploring Notion's Data Model: A Block-Based Architecture | Notion
            • GitHub - windows-internals-guide/security

              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 - windows-internals-guide/security
              • Git's database internals I: packed object store

                EngineeringOpen SourceGit’s database internals I: packed object storeThis blog series will examine Git’s internals to help make your engineering system more efficient. Part I discusses how Git stores its data in packfiles using custom compression techniques. Developers collaborate using Git. It is the medium that allows us to share code, work independently on our own machines, and then finally com

                  Git's database internals I: packed object store
                • An Introduction To Generics - The Go Programming Language

                  The Go 1.18 release adds support for generics. Generics are the biggest change we’ve made to Go since the first open source release. In this article we’ll introduce the new language features. We won’t try to cover all the details, but we will hit all the important points. For a more detailed and much longer description, including many examples, see the proposal document. For a more precise descrip

                    An Introduction To Generics - The Go Programming Language
                  • How Docker Desktop Networking Works Under the Hood | Docker

                    Modern applications make extensive use of networks. At build time it’s common to apt-get/dnf/yum/apk install a package from a Linux distribution’s package repository. At runtime an application may wish to connect() to an internal postgres or mysql database to persist some state, while also calling listen() and accept() to expose APIs and UIs over TCP and UDP ports. Meanwhile developers need to be

                      How Docker Desktop Networking Works Under the Hood | Docker
                    • A Guide to the Go Garbage Collector - The Go Programming Language

                      Introduction This guide is intended to aid advanced Go users in better understanding their application costs by providing insights into the Go garbage collector. It also provides guidance on how Go users may use these insights to improve their applications' resource utilization. It does not assume any knowledge of garbage collection, but does assume familiarity with the Go programming language. Th

                        A Guide to the Go Garbage Collector - The Go Programming Language
                      • How React server components work: an in-depth guide

                        React server components (RSC) is an exciting new feature that will have huge implications on page load performance, bundle size, and how we write React applications in the near future. We at Plasmic make a visual builder for React, and we care a lot about React performance — many of our customers use Plasmic to build performance-critical marketing and e-commerce sites. And so, even though RSC is s

                          How React server components work: an in-depth guide
                        • Understanding AWS Lambda’s invoke throttling limits | Amazon Web Services

                          AWS Compute Blog Understanding AWS Lambda’s invoke throttling limits This post is written by Archana Srikanta, Principal Engineer, AWS Lambda. When you call AWS Lambda’s Invoke API, a series of throttle limits are evaluated to decide if your call is let through or throttled with a 429 “Too Many Requests” exception. This blog post explains the most common invoke throttle limits and the relationship

                            Understanding AWS Lambda’s invoke throttling limits | Amazon Web Services
                          • Dumpster diving the Go garbage collector

                            Principal Engineer @ New Relic, Founding Engineer @ Pixie Labs Go is a garbage collected language. This makes writing Go simpler, because you can spend less time worrying about managing the lifetime of allocated objects. Memory management is definitely easier in Go than it is in, say, C++. But it’s also not an area we as Go developers can totally ignore, either. Understanding how Go allocates and

                              Dumpster diving the Go garbage collector
                            • RenderingNG  |  Chromium  |  Chrome for Developers

                              I'm Chris Harrelson, the engineering lead for Rendering (transforming HTML and CSS to pixels) in Blink. I've been deep in the trenches of rendering performance on the web for over eight years, with a personal goal of doing whatever I can to make delivering excellent UX on the web faster, easier, and more reliable. I'm excited for us to tell you about what we've done in that time to build a new, cu

                              • Sparkplug — a non-optimizing JavaScript compiler · V8

                                Show navigation Writing a high-performance JavaScript engine takes more than just having a highly optimising compiler like TurboFan. Particularly for short-lived sessions, like loading websites or command line tools, there’s a lot of work that happens before the optimising compiler even has a chance to start optimising, let alone having time to generate the optimised code. This is the reason why,

                                • How we built a serverless SQL database

                                  What is CockroachDB Serverless? If you’ve created a database before, you probably had to estimate the size and number of servers to use based on the expected traffic. If you guessed too low, your database would fall over under load and cause an outage. If you guessed too high or if your traffic came in bursts, you’d waste money on servers that are just sitting idle. Could there be a better way? Se

                                    How we built a serverless SQL database
                                  • 04.01.2022 - TypeScript/How the compiler compiles

                                    This article is inspired by the talk How the TypeScript compiler compiles◹, you should really check it out for a more in-depth understanding about the TypeScript’s compiling process. At a high level, the TypeScript compiler is a tool to help us analyze and compile the TypeScript code into JavaScript (*.js), as well as some type definition files (*.d.ts) or source maps (*.js.map). If the source fil

                                      04.01.2022 - TypeScript/How the compiler compiles
                                    • HTTP/3 Prioritization Demystified

                                      Robin Marx is a Web Performance Architect at Akamai Technologies. His main expertise is in network protocol performance, including HTTP/3 and QUIC, which was the topic of his PhD research. In a previous life he was a multiplayer game programmer and co-founder of LuGus Studios. YouTube videos of Robin are either humoristic technical talks or him hitting other people with longswords. If you deal wit

                                        HTTP/3 Prioritization Demystified
                                      • The Security Design of the AWS Nitro System - The Security Design of the AWS Nitro System

                                        Publication date: February 15, 2024 (Document revisions) Amazon Elastic Compute Cloud (Amazon EC2) is a web service that provides secure, resizable compute capacity in the cloud. It is designed to make web-scale cloud computing easier for developers. The AWS Nitro System is the underlying platform for all modern EC2 instances. This whitepaper provides a detailed description of the security design

                                        • Introducing Firefox’s new Site Isolation Security Architecture – Mozilla Hacks - the Web developer blog

                                          Introducing Firefox’s new Site Isolation Security Architecture Like any web browser, Firefox loads code from untrusted and potentially hostile websites and runs it on your computer. To protect you against new types of attacks from malicious sites and to meet the security principles of Mozilla, we set out to redesign Firefox on desktop. Site Isolation builds upon a new security architecture that ex

                                            Introducing Firefox’s new Site Isolation Security Architecture – Mozilla Hacks - the Web developer blog
                                          • A Deep Dive Into V8 | AppSignal Blog

                                            A majority of front-end developers deal with this buzzword all the time: V8. A big part of its popularity is due to the fact that it led JavaScript to a new level of performance. Yes, V8 is very fast. But, how does it perform its magic and why is it so responsive? The official docs state that “V8 is Google’s open source high-performance JavaScript and WebAssembly engine, written in C++. It is used

                                              A Deep Dive Into V8 | AppSignal Blog
                                            • Architecture Notes — System Design & Software Architectures Explained

                                              hey, we're architecture notes. learn about the systems you use everyday from the engineers who built them. ⚡

                                                Architecture Notes — System Design & Software Architectures Explained
                                              • Implementing Private Fields for JavaScript – Mozilla Hacks - the Web developer blog

                                                This post is cross-posted from Matthew Gaudet’s blog When implementing a language feature for JavaScript, an implementer must make decisions about how the language in the specification maps to the implementation. Sometimes this is fairly simple, where the specification and implementation can share much of the same terminology and algorithms. Other times, pressures in the implementation make it mor

                                                  Implementing Private Fields for JavaScript – Mozilla Hacks - the Web developer blog
                                                • Speeding up the JavaScript ecosystem - eslint

                                                  We've talked quite a bit about linting in the past two posts of this series, so I thought it's time to give eslint the proper limelight it deserves. Overall eslint is so flexible, that you can even swap out the parser for a completely different one. That's not a rare scenario either as with the rise of JSX and TypeScript that is frequently done. Enriched by a healthy ecosystem of plugins and prese

                                                    Speeding up the JavaScript ecosystem - eslint
                                                  • How image search works at Dropbox

                                                    Photos are among the most common types of files in Dropbox, but searching for them by filename is even less productive than it is for text-based files.  When you're looking for that photo from a picnic a few years ago, you surely don't remember that the filename set by your camera was 2017-07-04 12.37.54.jpg. Instead, you look at individual photos, or thumbnails of them, and try to identify object

                                                      How image search works at Dropbox
                                                    • How PlanetScale Boost serves your SQL queries instantly — PlanetScale

                                                      And yes, I know what you’re thinking. “This query is bananas, man. I would never run this in production!”. I know! I agree. The query is not particularly hard to understand, but if you try running it in a standard relational database, you’ll see that as soon as you have a few thousand star rows, the execution time of the query balloons out of control. Although this query uses the relational model

                                                        How PlanetScale Boost serves your SQL queries instantly — PlanetScale
                                                      • Deno KV internals: building a database for the modern web

                                                        Deno is designed to streamline web and cloud development with built-in modern tools, direct access to web platform APIs, and the capability to import modules via npm. Web apps very often require some persistent application state. Setting up a database involves numerous configuration steps and the subsequent integration of an ORM or other systems. What if you could access such a database without an

                                                          Deno KV internals: building a database for the modern web
                                                        • 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
                                                          • Improving Firefox stability on Linux – Mozilla Hacks - the Web developer blog

                                                            Roughly a year ago at Mozilla we started an effort to improve Firefox stability on Linux. This effort quickly became an example of good synergies between FOSS projects. Every time Firefox crashes, the user can send us a crash report which we use to analyze the problem and hopefully fix it: This report contains, among other things, a minidump: a small snapshot of the process memory at the time it c

                                                              Improving Firefox stability on Linux – Mozilla Hacks - the Web developer blog
                                                            • The Internals of Deno | The Internals of Deno

                                                              Updated for Deno 1.40 If you have any feedback for the book, including reviews, please send your note here: author.mayank.c@gmail.com.

                                                                The Internals of Deno | The Internals of Deno
                                                              • A minimal distributed key-value database with Hashicorp's Raft library | notes.eatonphil.com

                                                                A minimal distributed key-value database with Hashicorp's Raft library When I wrote the "build a distributed PostgreSQL proof of concept" post I first had to figure out how to use Hashicorp's Raft implementation. There weren't any examples I could find in the Hashicorp repo itself. And the only example I could find was Philip O'Toole's hraftd. It's great! However, I have a hard time following mult

                                                                • Go 1.22 inlining overhaul

                                                                  Go 1.22 inlining overhaul Austin Clements, with contributions from Damien Neil, Matthew Dempsky, Michael Pratt, and Than McIntosh Last update: Jul 20, 2023 The Go compiler’s inliner has never been particularly good. It wasn’t until Go 1.12, released in 2019, that the Go compiler supported inlining more than leaf functions, and we’ve slowly chipped away at more limitations of the inliner over the y

                                                                  • https://www.interdb.jp/pg/index.html

                                                                    • Zig Build System Internals

                                                                      Zig has a built-in build system for building projects. It runs on every platform Zig supports and is capable of building everything from simple executables and libraries to complex, multi-artifact, multi-step projects. This page will dive into how the internals of the Zig build system works. Build systems are an extremely important detail of any software project. When they work, they can feel like

                                                                      1