Are you over 18 and want to see adult content?
More Annotations
A complete backup of emeraldqueen.com
Are you over 18 and want to see adult content?
A complete backup of monstersinmotion.com
Are you over 18 and want to see adult content?
A complete backup of geo-naturpark.net
Are you over 18 and want to see adult content?
A complete backup of darululoomalihasanahlesunnat.com
Are you over 18 and want to see adult content?
Favourite Annotations
India Dropshipping Supplier & Wholesaler | Bafulia
Are you over 18 and want to see adult content?
Creality3D® Official Online Store-To Buy, Learn, Get support
Are you over 18 and want to see adult content?
Официальный сайт КубГУ | Кубанский государственный университет
Are you over 18 and want to see adult content?
Дешевые авиабилеты онлайн, купить авиабилеты дешево на Biletix.ru
Are you over 18 and want to see adult content?
Learn Indonesian Online with Podcasts - IndonesianPod101
Are you over 18 and want to see adult content?
Website Guider - Guider of Beginners
Are you over 18 and want to see adult content?
Jersey Vegas #1 worldwide sportsbook and casino betting site
Are you over 18 and want to see adult content?
Text
THINKING IN GO
MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMWHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
QUERIES EFFECT PERFORMANCE READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
THINKING IN GO
MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMWHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
QUERIES EFFECT PERFORMANCE READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. TECH WORKERS ARE GOOD PEOPLE Conclusion. When I read articles like The Other Tech Bubble, my reaction is often, “Yeah, there’s some truth to that, but let’s be fair and more precise because I know hundreds of tech workers who are great people, who deserve better than to be stereotyped.”This blog post has argued for that fairness and precision. I’m not acquitting Silicon Valley; there is a bubble here, but to 3 GOLANG ERROR TYPES Error message, package variable, custom type BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can beRESPONSE TIME SLA
Response time (or latency) percentiles are a ubiquitous measure of system performance. The P999 (99.9th percentile) is a high bar, so it’s a good metric to determine an SLA. For example, my team runs a system with an 800 millisecond response time SLA determined by theP999.
FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails DATABASE SCALABILITY: CONTENTION AND CROSSTALK New engineers might not know and experienced engineers might not believe that database systems do not and cannot scale gracefully to 100% system capacity but, rather and counterintutively, exhibit retrograde performance at some point less thanMYSQLSLA
mysqlsla The mysqlsla script has been archived. It is no longer developed or supported. You can download it from https://github.com/daniel-nichter/hackmysql.com/treeTHINKING IN GO
MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMWHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
QUERIES EFFECT PERFORMANCE READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
THINKING IN GO
MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMWHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
QUERIES EFFECT PERFORMANCE READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
HOW TO TEST THE DATABASE “How do I test the database?” is a question I’ve been asked by colleagues many times. There’s a good, clean solution, but let’s first step back from what seems to be the problem to unpack why “testing the database” is not special (but nonetheless important). APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. TECH WORKERS ARE GOOD PEOPLE Conclusion. When I read articles like The Other Tech Bubble, my reaction is often, “Yeah, there’s some truth to that, but let’s be fair and more precise because I know hundreds of tech workers who are great people, who deserve better than to be stereotyped.”This blog post has argued for that fairness and precision. I’m not acquitting Silicon Valley; there is a bubble here, but to 3 GOLANG ERROR TYPES Error message, package variable, custom type BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can beRESPONSE TIME SLA
Response time (or latency) percentiles are a ubiquitous measure of system performance. The P999 (99.9th percentile) is a high bar, so it’s a good metric to determine an SLA. For example, my team runs a system with an 800 millisecond response time SLA determined by theP999.
FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails DATABASE SCALABILITY: CONTENTION AND CROSSTALK New engineers might not know and experienced engineers might not believe that database systems do not and cannot scale gracefully to 100% system capacity but, rather and counterintutively, exhibit retrograde performance at some point less thanMYSQLSLA
mysqlsla The mysqlsla script has been archived. It is no longer developed or supported. You can download it from https://github.com/daniel-nichter/hackmysql.com/tree MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails MYSQL THREADS RUNNING Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
THINKING IN GO
After learning Go, it is necessary to think in Go in order to design and implement well-written, idiomatic Go. This blog post outlines aspects that I think are important for thinking in Go. A full exploration of these aspects could fill a book, but this only an orientation for experienced programmers new to Go. Programming languages have aspects which affect how we think, design, andimplement
PATH AND DIMENSION METRICS Dimension-based metrics are uniquely identified by name, not dimensions. That seems wrong at first, but the difference that makes it right is this: metric time series are uniquely identified by dimensions. Whereas path-based metrics couple data point name and MTS, dimension-based metrics decouple these. The decoupling is the purposeand power
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
TECH WORKERS ARE GOOD PEOPLE Conclusion. When I read articles like The Other Tech Bubble, my reaction is often, “Yeah, there’s some truth to that, but let’s be fair and more precise because I know hundreds of tech workers who are great people, who deserve better than to be stereotyped.”This blog post has argued for that fairness and precision. I’m not acquitting Silicon Valley; there is a bubble here, but to DATABASE SCALABILITY: CONTENTION AND CROSSTALK New engineers might not know and experienced engineers might not believe that database systems do not and cannot scale gracefully to 100% system capacity but, rather and counterintutively, exhibit retrograde performance at some point less than 3 GOLANG ERROR TYPES Error message, package variable, custom typeRESPONSE TIME SLA
Response time (or latency) percentiles are a ubiquitous measure of system performance. The P999 (99.9th percentile) is a high bar, so it’s a good metric to determine an SLA. For example, my team runs a system with an 800 millisecond response time SLA determined by theP999.
MYSQLSLA
mysqlsla The mysqlsla script has been archived. It is no longer developed or supported. You can download it from https://github.com/daniel-nichter/hackmysql.com/tree MYSQL THREADS RUNNINGMYSQL THREADS CONNECTEDMYSQL THREAD CACHEMYSQL THREAD CACHE SIZEMYSQL THREAD POOLMYSQL THREAD CONCURRENCYSQL SERVEROR MYSQL
Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails MYSQL THREADS RUNNINGMYSQL THREADS CONNECTEDMYSQL THREAD CACHEMYSQL THREAD CACHE SIZEMYSQL THREAD POOLMYSQL THREAD CONCURRENCYSQL SERVEROR MYSQL
Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
THINKING IN GO
After learning Go, it is necessary to think in Go in order to design and implement well-written, idiomatic Go. This blog post outlines aspects that I think are important for thinking in Go. A full exploration of these aspects could fill a book, but this only an orientation for experienced programmers new to Go. Programming languages have aspects which affect how we think, design, andimplement
PATH AND DIMENSION METRICS Dimension-based metrics are uniquely identified by name, not dimensions. That seems wrong at first, but the difference that makes it right is this: metric time series are uniquely identified by dimensions. Whereas path-based metrics couple data point name and MTS, dimension-based metrics decouple these. The decoupling is the purposeand power
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
TECH WORKERS ARE GOOD PEOPLE Conclusion. When I read articles like The Other Tech Bubble, my reaction is often, “Yeah, there’s some truth to that, but let’s be fair and more precise because I know hundreds of tech workers who are great people, who deserve better than to be stereotyped.”This blog post has argued for that fairness and precision. I’m not acquitting Silicon Valley; there is a bubble here, but to DATABASE SCALABILITY: CONTENTION AND CROSSTALK New engineers might not know and experienced engineers might not believe that database systems do not and cannot scale gracefully to 100% system capacity but, rather and counterintutively, exhibit retrograde performance at some point less than 3 GOLANG ERROR TYPES Error message, package variable, custom typeRESPONSE TIME SLA
Response time (or latency) percentiles are a ubiquitous measure of system performance. The P999 (99.9th percentile) is a high bar, so it’s a good metric to determine an SLA. For example, my team runs a system with an 800 millisecond response time SLA determined by theP999.
MYSQLSLA
mysqlsla The mysqlsla script has been archived. It is no longer developed or supported. You can download it from https://github.com/daniel-nichter/hackmysql.com/tree MYSQL THREADS RUNNINGMYSQL THREADS CONNECTEDMYSQL THREAD CACHEMYSQL THREAD CACHE SIZEMYSQL THREAD POOLMYSQL THREAD CONCURRENCYSQL SERVEROR MYSQL
Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails MYSQL THREADS RUNNINGMYSQL THREADS CONNECTEDMYSQL THREAD CACHEMYSQL THREAD CACHE SIZEMYSQL THREAD POOLMYSQL THREAD CONCURRENCYSQL SERVEROR MYSQL
Queries per second (QPS) measures database throughput, but it does not reflect how hard MySQL is working. The latter is measured by Threads_running, expressed as a gauge (whereas QPS is a rate).Before discussing Threads_running, let’s consider an analogy:. The image above is a digital instrument cluster from a car. COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
QUERIES EFFECT PERFORMANCE CRASH-SAFE MYSQL REPLICATIONSEE MORE ON HACKMYSQL.COMTHINKING IN GO
WHAT THE FLUSH?
There are two reasons. First, “buffer pool churn”: flushing old, unused pages to load newly requested data (pages). This happens because almost always the InnoDB buffer pool is much smaller than the total or working data set sizes. For example, having a 100G buffer pool for 500G of data. But even if this wasn’t true—let’s say wehave
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. READING OS/EXEC.CMD OUTPUT WITHOUT RACE CONDITIONS Golang Weekly issue 164 features a nice article, Advanced command execution in Go with os/exec, which details several ways of working with os/exec, especially how to read STDOUT and STDERR while the command is running.This common task is commonly done wrong, where “wrong” means “the code has a race condition”. This blog post shows how to read STDOUT and STDERR from an BOOTLOADER DESIGN PATTERN Extensibility is a lofty goal for software design, and difficult to achieve. The Wikipedia article notes: Extensible design in software engineering is to accept that not everything can be FIXING GHOSTED GTIDS When MySQL GTID auto-positioning fails COMPONENT-BASED SOFTWARE DESIGN Component-based design is the solution for software systems as well as the ubiquitous design of physical systems. Physical systems have certain limitations which preclude poor design. For example, the tires of a car cannot be grouped together, else the car will not work. Software, however, lacks such limitations, allowing engineers to doalmost
THINKING IN GO
After learning Go, it is necessary to think in Go in order to design and implement well-written, idiomatic Go. This blog post outlines aspects that I think are important for thinking in Go. A full exploration of these aspects could fill a book, but this only an orientation for experienced programmers new to Go. Programming languages have aspects which affect how we think, design, andimplement
PATH AND DIMENSION METRICS Dimension-based metrics are uniquely identified by name, not dimensions. That seems wrong at first, but the difference that makes it right is this: metric time series are uniquely identified by dimensions. Whereas path-based metrics couple data point name and MTS, dimension-based metrics decouple these. The decoupling is the purposeand power
APPROACHING A NEW SOFTWARE PROJECT Approaching a new software project is difficult for two reasons. First, there’s no “guiding star”, no objective starting point. The developer can begin from and proceed in many directions, which makes choosing difficult. DESIGN BEFORE IMPLEMENTATION I focus my attention on design rather than implementation for one simple reason: implementation details are easy to change when software is well designed. Or, from the business perspective, design is the most costly aspect of software to change, so I review for great and therefore cost-effective design. “Design” in this context is abroad
TECH WORKERS ARE GOOD PEOPLE Conclusion. When I read articles like The Other Tech Bubble, my reaction is often, “Yeah, there’s some truth to that, but let’s be fair and more precise because I know hundreds of tech workers who are great people, who deserve better than to be stereotyped.”This blog post has argued for that fairness and precision. I’m not acquitting Silicon Valley; there is a bubble here, but to DATABASE SCALABILITY: CONTENTION AND CROSSTALK New engineers might not know and experienced engineers might not believe that database systems do not and cannot scale gracefully to 100% system capacity but, rather and counterintutively, exhibit retrograde performance at some point less than 3 GOLANG ERROR TYPES Error message, package variable, custom typeRESPONSE TIME SLA
Response time (or latency) percentiles are a ubiquitous measure of system performance. The P999 (99.9th percentile) is a high bar, so it’s a good metric to determine an SLA. For example, my team runs a system with an 800 millisecond response time SLA determined by theP999.
MYSQLSLA
mysqlsla The mysqlsla script has been archived. It is no longer developed or supported. You can download it from https://github.com/daniel-nichter/hackmysql.com/treeHack MySQL
* About
* Archive
mysqlreport mysqlslamysqlsniffer
* Design
Command-line Interface Antipatterns* go
Go Antipatterns Idiomatic Go* metrics
Percentiles
QUERY METRICS REQUIREMENTS FOR MYSQL Let’s answer a question which, to my knowledge, has never been systematically addressed: What are the requirements for a production-ready query metrics app at scale? I am uniquely qualified to answer that because I have written four query metrics apps, two of which are the open-source standard for MySQL: pt-query-digest and the original (v1) code behind the query metrics/analysis part of Percona Monitoring and Management. I’ve also published a couple of packages related to query metrics: go-mysql/slowlog and go-mysql/query. Readmore...
Nov 1, 2020
#mysql #query-metrics ------------------------- * 2020-07-05 What the Flush? * 2020-06-29 21 Parameter Group Values to Change in Amazon RDS forMySQL
* 2020-05-31 Missing Writes with MySQL GTID * 2020-04-25 MySQL Threads Running * 2020-01-12 Queries Effect Performance * 2019-12-15 Fixing Ghosted GTIDs * 2019-06-29 Response Time SLA * 2019-04-12 Path and Dimension Metrics * 2019-03-25 3 Golang Error Types * 2018-12-16 3 Golang Channel Red Flags * 2018-12-02 Component-based Software Design * 2018-07-22 When MySQL Goes Away * 2018-05-13 Thinking in Go * 2018-02-04 Bootloader Design Pattern * 2018-01-28 Database Scalability: Contention and Crosstalk * 2018-01-23 Crash-safe MySQL Replication * 2017-12-31 Tech Workers Are Good People * 2017-12-10 Approaching a New Software Project * 2017-11-12 Ideas, Leaders, and Engineers * 2017-09-17 Five-Point Checklist for Excellent Software * 2017-09-05 Designing Tools for Integration * 2017-08-20 How To Test the Database * 2017-08-01 Design Before Implementation * 2017-06-17 Reading os/exec.Cmd Output Without Race Conditions * 2017-06-11 Custom MongoDB Replica Set Write Concern Copyright 2020 Daniel NichterDetails
Copyright © 2024 ArchiveBay.com. All rights reserved. Terms of Use | Privacy Policy | DMCA | 2021 | Feedback | Advertising | RSS 2.0