joecamel + internals   66

Rust: A unique perspective
"However, there is another way to explain Rust. This alternate story focuses on unique versus shared access to values in memory. I believe this version is useful for understanding why various checks exist and how they provide memory safety."
rust  programming  internals 
7 days ago by joecamel
On Rocks and Sand | Optimizing Postgres Column Order
When working with database capacity planning, there are a lot of variables to consider, and Postgres is no different in this regard. One of the elements which requires management is storage. However, there’s an aspect of storage that escapes inspection almost without exception, and it’s hiding in the shadows between the columns themselves.
database  optimization  performance  postgres  internals  tips 
17 days ago by joecamel
Exploring Query Locks in Postgres - Big elephants
Understanding query locking is key to using postgres concurrently. So let’s look at an example to learn more about how locking works and how to see what’s going on within your database.
postgres  internals  locks  performance  concurrency 
19 days ago by joecamel
Introduction · Linux Inside
A book-in-progress about the linux kernel and its insides.
book  kernel  linux  internals 
19 days ago by joecamel
Understanding Rust Lifetimes – NEAR Protocol – Medium
"in case of Rust it is more safety and better optimizations — you feel encouraged to master it but fail because it is not exactly intuitive and the formal rules are hard to find."
rust  programming  internals 
5 weeks ago by joecamel
lfittl/libpg_query: C library for accessing the PostgreSQL parser outside of the server environment
C library for accessing the PostgreSQL parser outside of the server.

This library uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parse tree.
postgres  internals  library  github  c  programming  sql 
june 2018 by joecamel
LiveOverflow - LiveOverflow
"This is a place to learn about topics such as buffer/heap overflows, reverse engineering, vulnerability analysis, debugging, fuzzing and generally hacking."
assembly  internals  hacking  security  videos 
november 2017 by joecamel
On Disk IO, Part 1: Flavours of IO – αλεx π – Medium
"Knowing how the IO works, which algorithms are used and under which circumstances can make lives of developers and operators much better: they will be able to make better choices upfront (based on what is in use by the database they’re evaluating), troubleshoot the performance issues when the database misbehaves (by comparing their workloads to the ones the database stack is intended to be used against) and tune their stack (by spreading the load, switching to a different disk type, file or operating system, or simply picking a different index type)."
io  programming  linux  internals  system.programming 
november 2017 by joecamel
Postgres Transactions Aren’t Fully Isolated – malisper.me
This post is part 1 of a three part series examining transaction isolation in Postgres.
postgres  db  internals  intro 
november 2017 by joecamel
Using the system catalogs to get column information - Postgres Compare
"A question came up on the pgsql-general mailing list regarding how to obtain column information from a PostgreSQL database. Finding the definition of database objects is something I spend a lot of time doing when working on the comparison and scripting engines for Postgres Compare."
postgres  db  internals 
november 2017 by joecamel
Understanding V8’s Bytecode – DailyJS – Medium
"This article explains V8’s bytecode format — which is actually easy to read once you understand some basic concepts."
v8  javascript  js  web  programming  internals  intro  overview 
august 2017 by joecamel
ELF Hello World Tutorial - Ciro Santilli
Introductory analysis of a simple example of the Executable and Linkable File format.
assembly  linux  programming  internals  elf 
may 2017 by joecamel
Memory Allocators 101 | James Golick
"For the last few weeks, I've been working on a couple of patches to tcmalloc, Google's super high performance memory allocator. I'm going to post about them soon, but first I thought it would be cool to give some background about what a memory allocator actually does. So, if you've ever wondered what happens when you call malloc or free, read on." HN: https://news.ycombinator.com/item?id=5720901
memory  programming  malloc  internals  intro  overview  google 
april 2017 by joecamel
V8: Behind the Scenes (February Edition feat. A tale of TurboFan) | Benedikt Meurer
"February (2017) has been an exciting and very, very busy month for me. As you have probably heard, we’ve finally announced that we will launch the Ignition+TurboFan pipeline in Chrome 59. So despite running late, and not making it for February actually, I’d like to take the time to reflect on the TurboFan tale a bit, and tell my story here. Remember, that everything you read here is my very personal opinion and doesn’t reflect the opinion of V8, Chrome or Google."
article  internals  chrome  v8  javascript  webdev  overview 
march 2017 by joecamel
IR is better than assembly — Idea of the day
"The crucial part is IR. It's a common language that sits between the high-level program and the low-level backend. IR is used to express high level concepts and is specific enough that any backend can produce a fast machine code.

IR is the heart of LLVM."
assembly  lowlevel  llvm  programming  internals 
february 2017 by joecamel
The Internals of PostgreSQL : Introduction
"In this document, the internals of PostgreSQL for database administrators and system developers are described."
postgres  sql  internals  book  database 
january 2017 by joecamel
Modern garbage collection – Mike’s blog – Medium
"Here are the different factors you will want to think about when designing a garbage collection algorithm..."
gc  internals  introduction  programming  overview 
january 2017 by joecamel
htop explained | peteris.rocks
Explanation of everything you can see in htop/top on Linux
linux  administration  internals  tools  server  intro 
december 2016 by joecamel
chenglou/intro-to-reason-compilation: Ready up!
"Reason is a syntax and tooling ecosystem for OCaml. The OCaml's compilation and build system can get rather sophisticated; This repository serves as a tutorial that explains some of the intricacies. It's always nice to know what really happens under the hood!"
ocaml  reason  languages  internals  guide  examples 
november 2016 by joecamel
"Runtime scheduling: theory and reality" by Eben Freeman - YouTube
"Can we quantify the tradeoffs between native threads and green threads? How expensive are context switches really? How can a scheduler trade off throughput and latency? How should we evaluate scheduler performance? And what do we really mean by performance, anyways?"
linux  scheduling  internals  yt  talk  strangeloop  programming 
september 2016 by joecamel
A fundamental introduction to x86 assembly programming
In this tutorial, I will help you gain a solid understanding of the x86 ISA from basic principles. I will focus more on building a mental model of what’s happening, rather than giving every detail precisely (which would be long and boring to read). If you want to make use of this knowledge, you should simultaneously refer to another tutorial that shows you how to write and compile a simple function, and also have a list of CPU instructions open for referencing. My tutorial will start out clear and simple, and add complexity in manageable steps – unlike other documentation that tend to lay out the information all at once.
assembly  x86  internals  programming  cs  intro  introduction  ebook 
may 2016 by joecamel
Locking in WebKit | WebKit
Back in August 2015 we replaced all spinlocks and OS-provided mutexes in WebKit with the new WTF::Lock (WTF stands for Web Template Framework). We also replaced all OS-provided condition variables with WTF::Condition. These new primitives have some cool properties...
concurrency  c++  locking  webkit  internals  overview  os 
may 2016 by joecamel
Following a Select Statement Through Postgres Internals - Pat Shaughnessy
Preparing for this presentation over the Summer, I decided to read through parts of the PostgreSQL C source code. I executed a very simple select statement and watched what Postgres did with it using LLDB, a C debugger. How did Postgres understand my query? How did it actually find the data I was looking for?
database  postgres  sql  internals  blog  post  c  source 
april 2016 by joecamel
PostgreSQL Bloat: origins, monitoring and managing
"PostgreSQL's MVCC model provides excellent support for running multiple transactions operating on the same data set. One natural consequence of its design is the existence of so-called "database bloat". Judging by the amount of questions raised in the Internet it is quite a common problem and not many people seem to know how to properly deal with it." HN: https://news.ycombinator.com/item?id=11425343
database  devops  postgres  pg  internals  blog  post  mvcc 
april 2016 by joecamel
tcpdump is amazing - Julia Evans
It took me 2 years, but I think now I love tcpdump. Before we go into why -- what's tcpdump?
tcpdump  tool  linux  wireshark  tshark  internals  network  sysadmin  debug 
march 2016 by joecamel
Coding for SSDs – Part 1: Introduction and Table of Contents | Code Capsule
I had to make sure I fully understood how SSDs work, so that I can optimize my hash table implementation to suit their internal characteristics. There is a lot of incomplete and contradictory information out there, and finding trustworthy information about SSDs was not an easy task. I had to do some substantial reading to find the proper publications and benchmarks in order to convince myself that, if I had to be coding for SSDs, I would know what I was doing.
hardware  optimization  programming  storage  ssd  series  article  internals 
april 2015 by joecamel
Let's build a browser engine! Part 1: Getting started
I’m building a toy HTML rendering engine, and I think you should too.
browser  programming  multipart  series  blog  rust  mozilla  engine  internals 
december 2014 by joecamel
Faster Websites: Crash Course on Web Performance - igvita.com
Clearly, three hours of web performance content is not enough. I gave an updated version of the below workshop at Fluent 2013, the videos for which are now online on YouTube - check it out!
videos  talk  performance  webdev  chrome  internals  browser  optimization  spdy  http  devtools 
november 2014 by joecamel
The Magic of strace - Chad Fowler
This was one of the most profoundly educational experiences of my career. It’s when I learned what may be for me the most important UNIX tool to date: strace.
HN: https://news.ycombinator.com/item?id=7155799 dtrace and other tools mentioned
debugging  internals  linux  programming  tool  strace  c  systems  personal.experience  blog  post 
november 2014 by joecamel
How statically linked programs run on Linux - Eli Bendersky's website
In this article I want to explore what happens when a statically linked program gets executed on Linux. By statically linked I mean a program that does not require any shared objects to run, even the ubiquitous libc. In reality, most programs one encounters on Linux aren't statically linked, and do require one or more shared objects to run. However, the running sequence of such programs is more involved, which is why I want to present statically linked programs first.
c  linux  programming  os  internals  linker  loader  assembly  c++ 
november 2014 by joecamel
Java Garbage Collection Distilled
Serial, Parallel, Concurrent, CMS, G1, Young Gen, New Gen, Old Gen, Perm Gen, Eden, Tenured, Survivor Spaces, Safepoints, and the hundreds of JVM startup flags. Does this all baffle you when trying to tune the garbage collector while trying to get the required throughput and latency from your Java application?
java  gc  jvm  internals  blog  post 
november 2014 by joecamel
Life of an instruction in LLVM - Eli Bendersky's website
LLVM is a complex piece of software. There are several paths one may take on the quest of understanding how it works, none of which is simple. I recently had to dig in some areas of LLVM I was not previously familiar with, and this article is one of the outcomes of this quest.
compiler  internals  llvm  programming  article 
november 2014 by joecamel

related tags

administration  algorithms  api  architecture  article  assembly  async  asyncio  blog  book  bootloader  browser  browsers  bug  c  c++  cache  chrome  code  comparison  compiler  comprehensive  concurrency  cpu  cs  css  database  db  debug  debugging  dev  development  devops  devtools  dtrace  ebook  elf  encoding  engine  examples  faq  firefox  floating.point  gc  github  google  graphics  guide  hacking  hardware  history  hn  http  ibm  illustration  intel  internals  interview  intro  introduction  io  java  javascript  js  jvm  kernel  languages  library  lin.clark  linker  links  linux  llvm  loader  locking  locks  lowlevel  lua  luajit  malloc  memory  mike.pall  mmap  mozilla  multipart  mvcc  network  networking  ocaml  opensource  optimization  os  overview  performance  personal.experience  pg  pg11  posix  post  postgres  presentation  programming  pycon  python  reason  resources  rust  scheduling  security  series  server  servo  simd  slides  source  spdy  sql  sqlite  ssd  storage  strace  strangeloop  sysadmin  system  system.programming  systems  talk  tcpdump  tips  tool  tools  tshark  tutorial  unicode  unix  v8  video  videos  visualization  web  webdev  webkit  webrtc  wireshark  x11  x86  xsystem  youtube  yt 

Copy this bookmark:



description:


tags: