This document provides an overview of garbage collection in Java. It begins with an introduction to the presenter Leon Chen and his background. It then discusses Java memory management and garbage collection fundamentals, including the young and old generations, minor and major garbage collections, and how objects are promoted between generations. The document provides examples of garbage collection using diagrams and discusses tuning the Java heap size based on the live data size. It emphasizes the importance of garbage collection logging for performance analysis.
Set operations allow combining results from multiple SELECT statements. There are four main types:
Union combines results and eliminates duplicates. Intersect returns only common records. Union All and Intersect All also show duplicate rows. Syntax involves a SELECT query followed by a set operator and another SELECT query.
Query processing and Query OptimizationNiraj Gandha
This presentation is made with many efforts and I believe that it will be proven as good presentation to clear the basic of query processing and optimization under the DBMS subject. The topics covered in this presentation are the basic fundamentals of the topic as suggested.
Optimizing Delta/Parquet Data Lakes for Apache SparkDatabricks
Matthew Powers gave a talk on optimizing data lakes for Apache Spark. He discussed community goals like standardizing method signatures. He advocated for using Spark helper libraries like spark-daria and spark-fast-tests. Powers explained how to build better data lakes using techniques like partitioning data on relevant fields to skip data and speed up queries significantly. He also covered modern Scala libraries, incremental updates, compacting small files, and using Delta Lakes to more easily update partitioned data lakes over time.
This document discusses Spark shuffle, which is an expensive operation that involves data partitioning, serialization/deserialization, compression, and disk I/O. It provides an overview of how shuffle works in Spark and the history of optimizations like sort-based shuffle and an external shuffle service. Key concepts discussed include shuffle writers, readers, and the pluggable block transfer service that handles data transfer. The document also covers shuffle-related configuration options and potential future work.
Cassandra is a structured storage system designed to run on a peer-to-peer network. It was created to handle large amounts of data and requests across many servers. Cassandra provides high availability with eventual consistency and incremental scalability. It uses a column-oriented data model and optimizes for writes over reads. Data is partitioned and replicated across nodes and gossip protocols are used for membership and failure detection.
Relational databases vs Non-relational databasesJames Serra
There is a lot of confusion about the place and purpose of the many recent non-relational database solutions ("NoSQL databases") compared to the relational database solutions that have been around for so many years. In this presentation I will first clarify what exactly these database solutions are, compare them, and discuss the best use cases for each. I'll discuss topics involving OLTP, scaling, data warehousing, polyglot persistence, and the CAP theorem. We will even touch on a new type of database solution called NewSQL. If you are building a new solution it is important to understand all your options so you take the right path to success.
Achieve Blazing-Fast Ingest Speeds with Apache ArrowNeo4j
The document is a presentation about using Apache Arrow to improve the speed of graph queries and analytics. It discusses how Arrow uses columnar data formats and vectorization to enable faster data processing. It also provides an example of how Arrow could be incorporated into Spark jobs and used with Beam to perform embarrassingly parallel graph processing. The presentation envisions future Neo4j integrations that would make Arrow processing transparent to data scientists.
This document provides an overview of different database types including relational, NoSQL, document, key-value, graph, and column family databases. It discusses the history and drivers behind the development of NoSQL databases, as well as concepts like horizontal scaling, the CAP theorem, and eventual consistency. Specific databases are also summarized, including MongoDB, Redis, Neo4j, and HBase.
The document describes the network database model and CODASYL DBTG model. Some key points:
- The network model uses a many-to-many relationship with owner and member records linked together.
- The DBTG model simplified this to one-to-one and one-to-many relationships. It uses segments, sets, and links to represent records, relationships, and connections between records.
- The DBTG model provides commands to retrieve, update, insert, and delete records as well as connect and disconnect them from sets. Programs access the database using templates, pointers, and status flags stored in a work area.
Transparent Data Encryption in PostgreSQL and Integration with Key Management...Masahiko Sawada
The document discusses transparent data encryption in PostgreSQL databases. It proposes encrypting data at the tablespace and buffer levels for minimal performance impact. A two-tier key architecture with separate master and data encryption keys enables fast key rotation. Integrating with key management systems provides flexible and robust key management. The solution aims to securely encrypt database content with low overhead.
This document discusses logical replication with pglogical. It begins by explaining that pglogical performs row-oriented replication and outputs replication data that can be used in various ways. It then covers the architectures of standalone PostgreSQL, physical replication, and logical replication. The rest of the document discusses key aspects of pglogical such as its output plugin, selective replication capabilities, performance and future plans, and examples of using the output with other applications.
This document discusses working with time series data using InfluxDB. It provides an overview of time series data and why InfluxDB is useful for storing and querying it. Key features of InfluxDB covered include its SQL-like query language, retention policies for managing data storage, continuous queries for aggregation, and tools for data collection, visualization and monitoring.
Robert Haas
Why does my query need a plan? Sequential scan vs. index scan. Join strategies. Join reordering. Joins you can't reorder. Join removal. Aggregates and DISTINCT. Using EXPLAIN. Row count and cost estimation. Things the query planner doesn't understand. Other ways the planner can fail. Parameters you can tune. Things that are nearly always slow. Redesigning your schema. Upcoming features and future work.
Ten query tuning techniques every SQL Server programmer should knowKevin Kline
From the noted database expert and author of 'SQL in a Nutshell' - SELECT statements have a reputation for being very easy to write, but hard to write very well. This session will take you through ten of the most problematic patterns and anti-patterns when writing queries and how to deal with them all. Loaded with live demonstrations and useful techniques, this session will teach you how to take your SQL Server queries mundane to masterful.
User Defined Aggregation in Apache Spark: A Love StoryDatabricks
This document summarizes a user's journey developing a custom aggregation function for Apache Spark using a T-Digest sketch. The user initially implemented it as a User Defined Aggregate Function (UDAF) but ran into performance issues due to excessive serialization/deserialization. They then worked to resolve it by implementing the function as a custom Aggregator using Spark 3.0's new aggregation APIs, which avoided unnecessary serialization and provided a 70x performance improvement. The story highlights the importance of understanding how custom functions interact with Spark's execution model and optimization techniques like avoiding excessive serialization.
Continuous Application with FAIR Scheduler with Robert XueDatabricks
This talk presents a continuous application example that relies on Spark FAIR scheduler as the conductor to orchestrate the entire “lambda architecture” in a single spark context. As a typical time series event stream analysis might involved, there are four key components:
– an ETL step to store the raw data
– a series of real time aggregation on the joint of streaming input and historical data to power a model
– model execution
– ad-hoc query for human inspection.
The key benefits of this setup compared to a typical design that has a bunch of Spark application running individually are
1. Decouple streaming batches process from triggering model calculation, model calculations are triggered at a different pace from the stream processing.
2. Model is always processing the latest data, using pure rdd APIs.
3. Launch various operations in different threads on the driver node, ensuring them got submitted to the appropriate fair scheduler pool. Let FAIR scheduler to do the resource distribution.
4. Share code and time by sharing the actual data transformation (like the rdds in the intermediate steps).
5. Support adhoc queries on intermediate state without a dedicated serving layer or output protocol.
6. Only one app to monitor and tune.
Introduction of Java GC Tuning and Java Java Mission ControlLeon Chen
This document provides an introduction and overview of Java garbage collection (GC) tuning and the Java Mission Control tool. It begins with information about the speaker, Leon Chen, including his background and patents. It then outlines the Java and JVM roadmap and upcoming features. The bulk of the document discusses GC tuning concepts like heap sizing, generation sizing, footprint vs throughput vs latency. It provides examples and recommendations for GC logging, analysis tools like GCViewer and JWorks GC Web. The document is intended to outline Oracle's product direction and future plans for Java GC tuning and tools.
The workshop is based on several Nikita Salnikov-Tarnovski lectures + my own research. The workshop consists of 2 parts. The first part covers:
- different Java GCs, their main features, advantages and disadvantages;
- principles of GC tuning;
- work with GC Viewer as tool for GC analysis;
- first steps tuning demo;
- comparison primary GCs on Java 1.7 and Java 1.8
The second part covers:
- work with Off-Heap: ByteBuffer / Direct ByteBuffer / Unsafe / MapDB;
- examples and comparison of approaches;
The off-heap-demo: https://github.com/moisieienko-valerii/off-heap-demo
The document discusses Java garbage collection. It begins with an introduction to garbage collection, explaining that it is used to release unused memory and each JVM can implement its own garbage collection algorithms. It then covers the main garbage collection algorithms of reference counting, mark and sweep, and stop and copy. It also discusses finalize() methods, reference types in Java including strong, soft, weak and phantom references, and tips for improving garbage collection performance in Java programs.
Garbage Collection, Tuning And Monitoring JVM In EBS 11i And R12sidg75
The document discusses garbage collection, tuning, and monitoring the Java Virtual Machine (JVM) in Oracle E-Business Suite 11i and R12. It begins by introducing garbage collection and its role in memory management. It then covers key garbage collection concepts like generations, collectors, and metrics for measurement. The document also lists some notable JVM parameters and provides guidance on monitoring the JVM. It concludes by mentioning future changes related to the JRockit JVM.
The document discusses garbage collection and object graphs. It lists objects and their outgoing references, showing how objects are connected and retained in memory. It also covers using Log4j in web applications and ensuring proper cleanup of logging resources during undeployment.
The document discusses Java locks and the ReentrantLock interface. It describes various methods for acquiring locks, such as lock(), tryLock(), and lockInterruptibly(). It notes that synchronized blocks do not guarantee thread access sequence or allow parameters like timeouts. ReentrantLock implements the Lock interface and allows the same thread to acquire the same lock multiple times. Its benefits include interruptible locking, timeouts, creating fair locks, and listing waiting threads.
Save JVM by Yourself: Real War Experiences of OOMLeon Chen
The document discusses garbage collection and object graphs. It lists objects and their outgoing references, showing how objects are connected and retained in memory. It also covers how Log4j must be configured for proper cleanup in web applications to avoid issues.
This presentation is a feedback of how I wrote a simple lock profiler on the JVM, including architectural overview, limits of the current approach and roadmap for future versions
Garbage First Garbage Collector (G1 GC) - Migration to, Expectations and Adva...Monica Beckwith
Learn what you need to know to experience nirvana in the evaluation of G1 GC even if your are migrating from Parallel GC to G1, or CMS GC to G1 GC
You also get a walk through of some case study data
G1 GC
Hadoop Meetup Jan 2019 - Dynamometer and a Case Study in NameNode GCErik Krogen
Erik Krogen of LinkedIn presents regarding Dynamometer, a system open sourced by LinkedIn for scale- and performance-testing HDFS. He discusses one major use case for Dynamometer, tuning NameNode GC, and discusses characteristics of NameNode GC such as why it is important, and how it interacts with various current and future GC algorithms.
This is taken from the Apache Hadoop Contributors Meetup on January 30, hosted by LinkedIn in Mountain View.
Secrets of Performance Tuning Java on KubernetesBruno Borges
Java on Kubernetes may seem complicated, but after a bit of YAML and Dockerfiles, you will wonder what all that fuss was. But then the performance of your app in 1 CPU/1 GB of RAM makes you wonder. Learn how JVM ergonomics, CPU throttling, and GCs can help increase performance while reducing costs.
Are your application's tail-latencies holding it back from delivering its near-real time SLOs? Do your in-memory processing platform's long pauses only get worse with increasing heap sizes? How about those latency spikes causing variability in your end-to-end latency for your multi-tiered distributed systems?
If any of the above keep you up at night, then have no fear as Z Garbage Collector (GC) is here and is production ready in JDK 15.
In this talk, Monica Beckwith will cover the basics of Z GC and contrast it with G1 GC (the current default collector for OpenJDK JDK 11 LTS and tip).
GC Tuning Confessions Of A Performance EngineerMonica Beckwith
This document provides an overview of garbage collection (GC) tuning and various GC algorithms used in OpenJDK HotSpot. It discusses key concepts like throughput collectors, latency-sensitive collectors, and the tradeoffs between throughput, latency and footprint. Specifically, it summarizes the Parallel Old, CMS and G1 garbage collectors - their goals, techniques used and failure scenarios. It also covers GC tuning concepts like heap configuration, GC logs and metrics.
Nowadays people usually talk more about big data, internet of things, and other buzzwords on various conferences. However, sometimes developers tend to not pay enough attention to the core things such as garbage collection. After having a short discussion with many somewhat experienced Java developers I came to a conclusion that most of them do not know how many garbage collectors there are in the latest JVM, and under what circumstances each of them should be enabled. This presentation is aimed to improve or refresh people’s knowledge on this core topic, and share a real use case when it helped us to resolve production issue.
Taming GC Pauses for Humongous Java Heaps in Spark Graph Computing-(Eric Kacz...Spark Summit
The document discusses tuning the Garbage First (G1) garbage collector in Java 8 to reduce garbage collection pauses for large heaps used in Spark graph computing workloads. It was found that the default G1 settings resulted in lengthy full garbage collections over 100 seconds. After analyzing the garbage collection logs, the main issue was identified as the concurrent marking phase not completing before a full collection was needed. Increasing the number of concurrent marking threads from 8 to 20 addressed this by speeding up the concurrent phase. With this tuning, no full collections occurred and total stop-the-world pause time was reduced to under a minute, a significant improvement over the original implementation.
This session brings to your attention how several millions of dollars are wasted and what you can do to save money. Optimizing garbage collection performance not only saves money, but also improves the overall customer experience as well.
High Performance Erlang - Pitfalls and SolutionsYinghai Lu
Presented at Erlang Factory 2016, San Francisco, CA.
Erlang is widely used for building concurrent applications. However, when we push the performance of our Erlang based application to handle millions of concurrent clients, some Erlang scalability issues begin to show and some conventional programming paradigm of Erlang no longer hold. We would like to share some of these issue and how we address them. In addition, we share some of our experience on how to profile an Erlang application to identify bottlenecks.
We will take a deep look at some of the basic mechanisms of Erlang and show how they behave under high load and parallelism, which includes message delivery, process management and shared data structures such as maps and ETS tables. We will demonstrate their limitations and propose techniques to alleviate the issues.
We will also share profiling techniques on how to find those bottlenecks in Erlang applications across different levels. We will share techniques for writing highly performant Erlang applications.
All the fundamental concepts and tools for understanding performance tuning in Java. Garbage collection, memory management and collector types and tools for profiling Java applications.
The document discusses troubleshooting memory problems in Java applications. It begins with an overview of common symptoms of memory issues like OutOfMemoryErrors, excessive garbage collection, and long GC pauses. The rest of the document details strategies for diagnosing memory issues such as analyzing GC logs and heap dumps, ensuring the Java heap is sized appropriately, and tuning garbage collection thresholds.
The document provides an overview of how to read and understand garbage collection (GC) log lines from different Java vendors and JVM versions. It begins by explaining the parts of a basic GC log line for the OpenJDK GC log format. It then discusses GC log lines for G1 GC and CMS GC in more detail. Finally, it shares examples of GC log formats from IBM JVMs and different levels of information provided. The document aims to help readers learn to correctly interpret GC logs and analyze GC behavior.
Java performance tuning involves diagnosing and addressing issues like slow application performance and out of memory errors. The document discusses Java performance problems and their solutions, tuning tips, and monitoring tools. Some tips include tuning JVM parameters like heap size, garbage collection settings, and enabling parallel garbage collection for multi-processor systems. Tools mentioned include JConsole, VisualVM, JProfiler, and others for monitoring memory usage, thread activity, and garbage collection.
The document discusses various techniques for optimizing Java application performance, including:
1. Classic techniques like tuning JVM options, garbage collection, and memory settings.
2. Code optimizations like avoiding object creation, using primitives over wrappers, and micro-optimizations.
3. Tools for analyzing performance like JVisualVM, JMH, and different profilers.
The document provides examples and comparisons of different optimizations and their performance impacts. It also discusses considerations for optimizing embedded and Android applications differently due to their unique constraints.
This document discusses memory management techniques in Sun JDK 1.6. It begins by describing common OS memory allocation and garbage collection algorithms like reference counting, mark-sweep, and copying collection. It then details how Sun JDK implements generation scavenging GC using parallel and concurrent algorithms. Optimization techniques for young and full GCs like type inference, card tables, and partial compaction are also examined. Finally, the document briefly outlines some JRockit GC optimizations including pinned objects, two-color marking, and adaptive generation sizing.
Kris Mok presented on customizing the JVM at Taobao to improve performance and diagnostics. Some key customizations discussed include:
1) Creating a GC Invisible Heap (GCIH) to improve performance by removing large static data from GC management.
2) Optimizing JNI wrappers to reduce overhead of JNI calls by handling common cases more efficiently.
3) Adding support for new instructions like CRC32c to take advantage of hardware acceleration.
4) Adding flags like -XX:+PrintGCReason to provide more information on the direct causes of GC cycles.
5) Tracking huge object and array allocations to help diagnose out of memory errors.
At Criteo we are using both .NET CLR runtime and JVM one. At first look it seems there are very similar: a bytecode, a JIT, a GC, … but in fact there is some differences in the implementation and in the vision of the targeted applications and their requirements
Let’s dig into those differences with the pros & cons
Predicting Test Results without Execution (FSE 2024)Andre Hora
As software systems grow, test suites may become complex, making it challenging to run the tests frequently and locally. Recently, Large Language Models (LLMs) have been adopted in multiple software engineering tasks. It has demonstrated great results in code generation, however, it is not yet clear whether these models understand code execution. Particularly, it is unclear whether LLMs can be used to predict test results, and, potentially, overcome the issues of running real-world tests. To shed some light on this problem, in this paper, we explore the capability of LLMs to predict test results without execution. We evaluate the performance of the state-of-the-art GPT-4 in predicting the execution of 200 test cases of the Python Standard Library. Among these 200 test cases, 100 are passing and 100 are failing ones. Overall, we find that GPT-4 has a precision of 88.8%, recall of 71%, and accuracy of 81% in the test result prediction. However, the results vary depending on the test complexity: GPT-4 presented better precision and recall when predicting simpler tests (93.2% and 82%) than complex ones (83.3% and 60%). We also find differences among the analyzed test suites, with the precision ranging from 77.8% to 94.7% and recall between 60% and 90%. Our findings suggest that GPT-4 still needs significant progress in predicting test results.
How to Secure Your Kubernetes Software Supply Chain at ScaleAnchore
Achieving comprehensive security visibility in Kubernetes environments is essential for maintaining robust and compliant cloud-native applications. In this exclusive webinar, Anchore and Spectro Cloud team up to showcase how to enhance your Kubernetes security posture with SBOM (Software Bill of Materials) management and vulnerability scanning.
Join Cornelia Davis, VP of Product, Spectro Cloud and Alan Pope, Director of Developer Relations, Anchore to learn how to elevate your Kubernetes security visibility and protect your cloud-native applications effectively.
—Discover how Anchore can be integrated with Spectro Cloud Palette to take SBOM scanning to the next level, delivering fully automated software compliance
—Gain valuable insights into best practices for securing your Kubernetes workloads, ensuring compliance, and improving your DevSecOps processes.
Unlocking the Future of Artificial IntelligencedorinIonescu
Unlock the Future: Dive into AI Today! Videnda AI specializes in developing advanced artificial intelligence solutions, including visual dictionaries and language learning tools that leverage immersive virtual travel experiences. Stay Ahead of the Curve: Master AI Now! Our AI technology integrates machine learning and neural networks to enhance education and business applications. AI: The Next Frontier. Are You Ready to Explore? With a focus on real-time AI solutions and deep learning models, Videnda AI provides innovative tools for multilingual communication and immersive learning.
In this course, you'll find a series of engaging videos packed with vibrant animations that break down complex AI concepts into digestible pieces. Our curriculum covers AI models such as Convolutional Neural Networks (CNN), Multi-Layer Perceptrons (MLP), Generative Adversarial Networks (GAN), and Transformers, providing a solid understanding of these models and their real-world applications. We also offer hands-on experience with Generative AI tools like ChatGPT and Midjourney, and Python programming tutorials to help you implement AI algorithms and build your own AI applications.
We are proud participants in the Nvidia Inception Program, driving AI innovation across various industries. By the end of our course, you'll have a strong understanding of AI principles, enhanced Python programming skills, and practical experience with state-of-the-art Generative AI tools. Whether you're looking to kickstart a career in AI or simply curious about this revolutionary technology, Videnda AI is your partner in mastering the future of artificial intelligence.
Old Tools, New Tricks: Unleashing the Power of Time-Tested Testing ToolsBenjamin Bischoff
In the rapidly evolving landscape of software development and testing, it is tempting to chase the latest tools and technologies. However, some of the most effective solutions have been in existence for decades. In this talk, we’ll delve into the enduring value of these timeless testing tools.
We’ll explore how established tools like Selenium, GNU Make, Maven, and Bash remain vital in today’s software development and testing toolkit even though they have been around for a long time (some were even invented before I was born). I’ll share examples of how these tools have addressed our testing and automation challenges, showcasing their adaptability, versatility, and reliability in various scenarios. I aim to demonstrate that sometimes, the “old” ways can indeed be the best ways.
Fix Production Bugs Quickly - The Power of Structured Logging in Ruby on Rail...John Gallagher
Rails apps can be a black box. Have you ever tried to fix a bug where you just can’t understand what’s going on? This talk will give you practical steps to improve the observability of your Rails app, taking the time to understand and fix defects from hours or days to minutes. Rails 8 will bring an exciting new feature: built-in structured logging. This talk will delve into the transformative impact of structured logging on fixing bugs and saving engineers time. Structured logging, as a cornerstone of observability, offers a powerful way to handle logs compared to traditional text-based logs. This session will guide you through the nuances of structured logging in Rails, demonstrating how it can be used to gain better insights into your application’s behavior. This talk will be a practical, technical deep dive into how to make structured logging work with an existing Rails app.
I talk about the Steps to Observable Software - a practical five step process for improving the observability of your Rails app.
Crowd Strike\Windows Update Issue: Overview and Current Statusramaganesan0504
Crowd Strike\Windows Update Issue: Overview and Current Status
Discover the latest on the CrowdStrike Windows update issue, including an overview, current status, and support steps for affected customers. Learn about the identified defect, its impact on Windows hosts, and CrowdStrike's committed actions to ensure ongoing security and stability.
What is CrowdStrike?
CrowdStrike is a prominent cybersecurity technology company that specializes in providing advanced threat intelligence and endpoint protection solutions. Founded in 2011 by George Kurtz, Dmitri Alperovitch, and Gregg Marston, CrowdStrike has quickly established itself as a leader in the cybersecurity industry. Here are some key aspects of
The code is written and the tests pass. I just have to commit this last round of changes to my branch. Wait, why does that say committed to main? Did I commit all those changes to main? Arghh! I can’t redo all of this!
Committing changes to the wrong branch, forgetting files, misspelling the commit message, and needing to undo commits are some of the “advanced” features of Git that we normal people run into way too often and need help with. The fixes are often easy – once you know what they are. But in the heat of the moment, with the deadline (or Friday afternoon) approaching, it isn’t always easy to figure out what magic spell to cast to get Git to do what you need.
We’ll spend some time looking at typical Git situations people get themselves into, and then we’ll demonstrate how to get out of them. This isn’t about Git internals or a Git master’s class – this real-world Git when things aren’t going right. And there will be plenty of time for questions, so bring your “best” Git nightmare scenarios so we can figure out how to recover.
Mastering MicroStation DGN: How to Integrate CAD and GISSafe Software
Dive deep into the world of CAD-GIS integration and elevate your workflows to nexl-level efficiency levels. Discover how to seamlessly transfer data between Bentley MicroStation and leading GIS platforms, such as Esri ArcGIS.
This session goes beyond mere CAD/GIS conversion, showcasing techniques to precisely transform MicroStation elements including cells, text, lines, and symbology. We’ll walk you through tags versus item types, and understanding how to leverage both. You’ll also learn how to reproject to any coordinate system. Finally, explore cutting-edge automated methods for managing database links, and delve into innovative strategies for enabling self-serve data collection and validation services.
Join us to overcome the common hurdles in CAD and GIS integration and enhance the efficiency of your workflows. This session is perfect for professionals, both new to FME and seasoned users, seeking to streamline their processes and leverage the full potential of their CAD and GIS systems.
Three available editions of Windows Servers crucial to your organization’s op...Q-Advise
Three available editions of Windows Servers crucial to your organization’s operations
Windows Server, Microsoft’s robust operating system, is the cornerstone of enterprise IT infrastructure, tailored for mission-critical operations. It helps in managing enterprise-level tasks, including data storage, applications, and communication.
Proper licensing of Windows Server is essential for both legal compliance and optimal functionality within business environments.
Windows Server comes in various edition and before any edition is used in your organization, it is required you license them appropriately. The licensing can be complex and capital demanding when you don’t know what you want or understand the licensing requirements.
Even if successfully licensed, there are various activities you can practice as an organization to make sure your Server is operating optimally and there is real value for money. This requires a deeper understanding of best practices and our team of cloud and licensing experts can be of support.
Send the team an email, info@q-advise.com let’s have a look at your needs, together with you decide which licensing model will best work in your case, assist you with savings options and share with you how pre-owned licensing can help you get licensed adequately also.
The SQDC (Safety, Quality, Delivery, Cost) process enhances manufacturing performance through daily safety meetings, defect tracking, and waste reduction. Orcalean’s FactoryKPI digital dashboard streamlines this process, providing real-time data and AI-powered analytics for continuous improvement.
Unlocking value with event-driven architecture by Confluentconfluent
Sfrutta il potere dello streaming di dati in tempo reale e dei microservizi basati su eventi per il futuro di Sky con Confluent e Kafka®.
In questo tech talk esploreremo le potenzialità di Confluent e Apache Kafka® per rivoluzionare l'architettura aziendale e sbloccare nuove opportunità di business. Ne approfondiremo i concetti chiave, guidandoti nella creazione di applicazioni scalabili, resilienti e fruibili in tempo reale per lo streaming di dati.
Scoprirai come costruire microservizi basati su eventi con Confluent, sfruttando i vantaggi di un'architettura moderna e reattiva.
Il talk presenterà inoltre casi d'uso reali di Confluent e Kafka®, dimostrando come queste tecnologie possano ottimizzare i processi aziendali e generare valore concreto.
Test Polarity: Detecting Positive and Negative Tests (FSE 2024)Andre Hora
Positive tests (aka, happy path tests) cover the expected behavior of the program, while negative tests (aka, unhappy path tests) check the unexpected behavior. Ideally, test suites should have both positive and negative tests to better protect against regressions. In practice, unfortunately, we cannot easily identify whether a test is positive or negative. A better understanding of whether a test suite is more positive or negative is fundamental to assessing the overall test suite capability in testing expected and unexpected behaviors. In this paper, we propose test polarity, an automated approach to detect positive and negative tests. Our approach runs/monitors the test suite and collects runtime data about the application execution to classify the test methods as positive or negative. In a first evaluation, test polarity correctly classified 117 tests as as positive or negative. Finally, we provide a preliminary empirical study to analyze the test polarity of 2,054 test methods from 12 real-world test suites of the Python Standard Library. We find that most of the analyzed test methods are negative (88%) and a minority is positive (12%). However, there is a large variation per project: while some libraries have an equivalent number of positive and negative tests, others have mostly negative ones.
Tube Magic Software | Youtube Software | Best AI Tool For Growing Youtube Cha...David D. Scott
Tube Magic Software is your ultimate tool for creating stunning video content with ease. Designed with both beginners and professionals in mind, it offers a user-friendly interface packed with powerful features. From seamless editing to eye-catching effects, Tube Magic helps you bring your creative vision to life. Elevate your videos and captivate your audience effortlessly. Join our community of content creators and experience the magic today!
Bring Strategic Portfolio Management to Monday.com using OnePlan - Webinar 18...OnePlan Solutions
Unlock the full potential of your projects with OnePlan’s seamless integration with monday.com. Join us to discover how OnePlan enhances monday.com by aligning your portfolio of projects with your organization’s strategic goals, optimizing resource allocation, and streamlining performance tracking. Learn how this powerful combination can drive efficiency, cost savings, and strategic success within your organization.
2. 陳逸嘉 (Leon
Chen)
• Master
of
NTHU
CS
• More
than
15
years
in
Java/JEE,
as
programmer,
architect,
developer
leader
and
consultant,
in
finance/telecom
domain.
• 工研院
• 得捷
• 新光人壽
• Ericsson
• Oracle
• 文曄科技 (WT
Microelectronics)
2
3. 著作
• TW
Patent
182927,
一種文章切割方法,
2003,
陳逸嘉,
林一中
• TW
Patent
206819,
自動服務組合方法及系統,
2004,
陳逸嘉,
許維德,
洪
鵬翔
• US
Patent
7,617,174,
Method
and
system
for
automaRc
service
composiRon,
2009,
Leon
Chen,
Wei-‐Tek
Hsu,
Peng-‐Hsiang
Hung
3
35. GC
Logging
in
ProducRon
• Don’t
be
afraid
to
enable
GC
logging
in
producRon
– Very
helpful
when
diagnosing
producRon
issues
• Extremely
low
/
non-‐existent
overhead
– Maybe
some
large
files
in
your
file
system.
– We
are
surprised
that
customers
are
sRll
afraid
to
enable
it
35
37. Most
Important
GC
Logging
Parameters
• You
need
at
least:
– -‐XX:+PrintGCDetails
– -‐XX:+PrintGCTimeStamps
• Add
-‐XX:+PrintGCDateStamps
if
you
must
know
the
Rme
• Also
useful
– -‐Xloggc:file
– Rotate
GC
Log,
Aqer
Java
1.6_34
(or
1.7_2):
-‐XX:+UseGCLogFileRotaRon
-‐XX:NumberOfGCLogFiles=5
-‐XX:GCLogFileSize=10M
37
38. GCViewer
–
Offline
analysis
of
GC
logs
h[ps://github.com/chewiebug/GCViewer
38
42. Hotspot
Tuning
-‐
Sizing
Heap
• Young
GeneraRon
size
determines
• Frequency
of
minor
GC
• Number
of
objects
reclaimed
in
minor
GC
• Old
GeneraRon
Size
• Should
hold
applicaRon's
steady-‐state
live
data
size
• Try
to
minimize
frequency
of
major
GC’s
• JVM
footprint
should
not
exceed
physical
memory
• Max
of
80-‐90%
RAM
(leave
room
for
OS)
• Thumb
Rule:
Try
to
maximize
objects
reclaimed
in
young
gen.
Minimize
Full
GC
frequency
42
43. Calculate Live Data Size (LDS)
• 經過 full
GC
後,
所剩下的
heap
size
• Make
sure
you
get
full
GCs
during
steady-‐state
• Induce
a
couple
if
necessary
– JConsole
/
VisualVM
– jmap
-‐histo:live
pid
– System.gc
• Remove
it
before
deployment.
:-‐)
43
46. IniRal
Heap
ConfiguraRon
• Rule
of
thumb
– Set
-‐Xms
and
-‐Xmx
to
3x
to
4x
LDS
– Set
both
-‐XX:PermSize
and
-‐XX:MaxPermSize
to
around
1.2x
to
1.5x
the
max
perm
gen
size
– Set
the
generaRon
sizes
accordingly
• Young
gen
should
be
around
1x
to
1.5x
LDS
• Old
gen
should
be
around
2x
to
3x
LDS
• e.g.,
young
gen
should
be
around
1/3-‐1/4
of
the
heap
size
46
47. Hotspot
JVM
Heap
Layout
47
Young
–Xmn768m
Old
(Tenured)
Permanent
NaRve
-‐Xms2g
–Xmx2g
-‐XX:PermSize
-‐XX:MaxPermSize
For
LDS
of
512m
:
-‐Xmn768m
-‐Xms2g
-‐Xmx2g
49. High
Throughput
vs.
Low
Latency
49
High
Throughput
Low
Latency
App Thread
GC Thread
專心
分心
較低
較高
較長
較短
Stop the world
Total Cost
50. High
Throughput
vs.
Low
Latency
• For
most
applicaRons,
GC
overhead
is
small
– 2%
–
5%
• High
Throughput
GCs
– Move
most
work
to
GC
pauses
– ApplicaRon
threads
do
as
li[le
as
possible
– Least
overall
GC
overhead
• Low
Latency
(Pause)
GCs
– Move
work
out
of
GC
pauses
– ApplicaRon
threads
do
more
work
• Bookkeeping
for
GC
more
expensive
– More
overall
GC
overhead
50
51. ApplicaRon
Requirement
• Different
applicaRons
have
different
requirements
– Higher
Throughput:
• Batch
processing
• Web
applicaRon:
pauses
during
garbage
collecRon
may
be
tolerable,
or
simply
obscured
by
network
latencies
– Lower
Latencies:
• InteracRve
graphics
applicaRon
51
52. HotSpot
Garbage
Collectors
in
Java
SE
6
52
G1
-XX:+UseSerialGC
-XX:+UseConcMarkSweepGC -XX:+UseParallelOldGC
-XX:+UseParallelGC
-‐XX:+UseParNewGC
53. HotSpot
Garbage
Collectors
in
Java
SE
6
53
G1
-XX:+UseSerialGC
-XX:+UseConcMarkSweepGC -XX:+UseParallelOldGC
-XX:+UseParallelGC
-‐XX:+UseParNewGC
74. Summarize
• Professional
developer
必須非常了解
variables,
objects
的
life
cycle,
objects
何時有
資格被會收
• GC
will
hurt
system
performance
• Must
monitor
GC
acRviRes
• Must
enable
GC
logging
75. Tuning
Procedures
• Observer
LDS
to
decide
iniRal
size
se~ng
• Use
parallel
GC
first
• If
the
GC
pause
Rme
can’t
be
accepted,
then
trying
to
use
CMS
• If
heap
is
over
6G,
and
look
for
lower
down
pause
Rme,
you
can
consider
G1
• Monitoring
-‐
Analyzing
-‐
Tuning
-‐
Monitoring
-‐
…
75