Pureperformance

In 2018 Adrian Cockcroft was quoted with: “Chaos Engineering is an experiment to ensure that the impact of failures is mitigated”! In 2019 we sit down with one of his colleagues, Adrian Hornsby (@adhorn), who has been working in the field of building resilient systems over the past years and who is now helping companies to embed chaos engineering into their development culture. Make sure to read Adrian’s chaos engineering blog and then listen in and learn about the 5 phases of chaos engineering: Steady State, Hypothesis, Run Experiment, Verify, Improve. Also learn why chaos engineering is not limited to infrastructure or software but can also be applied to humans.Adrian on Twitter:https://twitter.com/adhornAdrian's Blog:https://medium.com/@adhorn/chaos-engineering-ab0cc9fbd12a

Adrian Hornsby (@adhorn) has dedicated his last years helping enterprises around the world to build resilient systems. He wrote a great blog series titled “Patterns for Resilient Architectures” and has given numerous talks about this such as Resiliency and Availability Design Patterns for the Cloud at DevOne in Linz earlier this year.Listen in and learn more about why resiliency starts with humans, why we need to version everything we do, why default timeouts have to be flagged, how to deal with retries and backoffs and why every distributed architect has to start designing systems that provide different service levels depending on the overall system health state.Links:Adrian on Twitter: https://twitter.com/adhornMedium Blog Post: https://medium.com/@adhorn/patterns-for-resilient-architecture-part-1-d3b60cd8d2b6Adrian's DevOne talk: https://www.youtube.com/watch?v=mLg13UmEXlwDevOne Intro video: https://www.youtube.com/watch?v=MXXTyTc3SPU

Susanne Kaiser (@suksr) has transformed her company from monolith on-premise into a SaaS solution running on a microservice architecture: Successfully! Nowadays she consults companies that need to find their “core domain”, break up and re-fit their architectures and organizational structure in order to truly get the benefit of microservices.In this podcast you learn which questions you need to ask before starting a microservice project, how to find your true “core domain”, how to restructure not only your code but also organization and you get exposed to the concept of Wardley Maps which help you decide what to build vs what to outsource in order to deliver value to your end users the most efficient way.Links:Susannne on Twitter - https://twitter.com/suksrDevOne Conference Page - https://devexperience.ro/speakers/susanne-kaiser/Wardley Maps Microservices presentation - https://www.slideshare.net/SusanneKaiser3/preparing-for-a-future-microservices-journey-with-wardley-maps

To service mash or not? That’s a good question! Not every architecture and project needs a service mesh but for running distributed microservices architectures service mashes provide a lot of essential features such as service discovery, traffic routing, security, observability ..We invited Matt Turner (@mt165), CTO at Native Wave, to tell us all we need to know about service mashes. We get a deep dive into Istio, one of the most popular current service mashes, the architecture and how the individual components such as Envoy, Pilot, Mixer and Citadel work together. We also chat about the tradeoff between performance, latency, throughput and service mash capabilities. If you want to learn more make sure to check out Matt’s online content such as blogs and recorded conference presentations on https://mt165.co.uk/.Native Wave https://nativewave.io/Istio vs. Linkerd CPU Overhead Benchmarks by Michael Kipper Initial Observations: https://medium.com/@michael_87395/benchmarking-istio-linkerd-cpu-c36

Keptn (@keptnProject) is an open source control plane for Kubernetes enabling continuous delivery and automated operations. In this session we chat with Dirk Wallerstorfer (@wall_dirk) who is leading the keptn development team. We learn from Dirk why they choose knative as serverless framework to let keptn connect to other DevOps tools in the toolchain, how the event driven architecture works, which use cases are supported and where the road is heading.If you are interested also check out our Getting Started with keptn YouTube Tutorial, join the keptn slack channel, keep an eye at the keptn community and give feedback after trying out keptn yourself by following the following installation instructions: https://keptn.sh/docs/Links:keptn on Twitter - https://twitter.com/keptnProjectDirk on Twitter - https://twitter.com/wall_dirkknative - https://cloud.google.com/knative/Keptn Video - https://www.youtube.com/watch?v=0vXURzikTacKeptn Slack - https://keptn.slack.com/join/shared_invite/enQtNTUxMTQ1MzgzMzUxLTcxMzE0O

Can you explain Cloud Native? What are the key OpenSource frameworks you need to know? How about all these OpenSource Licensing models? Why do they exist? Which one to use? What are the monetization models and why to watch closely how Big IT & Cloud companies are impacting this space?Carmen Andoh (@carmatrocity), Program Manager at Google and former Infrastructure Engineer at Travis CI, helps us understand how to navigate the Cloud Native & OpenSource world and gives answer to all the questions above. The IT world is changing but its up to us to shape the future by inventing it. If you want to learn more after listening check out the CNCF Trailmap and follow up with Carmen on social media to get access to her material around that topic!Trailmaphttps://github.com/cncf/trailmap

Imagine a future where we deploy every code change directly into production because feature flags eliminated the need for staging. Feature flags allow us to deploy any code change, but only launch the feature to a specific set of users that we want to expose to new capabilities. Monitoring the usage and the impact enables continuous experimentation: optimizing what is not perfect yet and throw away features (technical debt) that nobody really cares about. So – what are feature flags?We got to chat with Heidi Waterhouse (@wiredferret), Developer Advocate at LaunchDarkly (https://launchdarkly.com/), who gives as a great introduction on Feature Flags, how organizations actually define a feature and why it is paramount to differentiate between Deploy and Launch. We learn how to test feature flags, what options we have to enable features for a certain group of users and how important it is to always include monitoring. IF you want to learn more about feature flags check out http://featureflags.io/. If you want to

Self-Healing, Auto-Remediation: Magic words for most IT Leaders! When starting those kinds of projects teams realize their lack of maturity or even understanding of their current IT landscape to even think about Self-Healing. In other scenarios Self-Healing is misunderstood as a band-aid for “keeping the lights on” in order to buy more time for outstanding product improvements vs investing in the core architecture.In this podcast we invited Jon Hathaway, CEO of HATech, and Jarvis Mishler, Solutions Architect Team Lead at HATech (@hatechllc), to learn about how they help organizations assess and improve the maturity of their IT Systems & processes, which auto-remediation actions they typically implement and why real self-healing is not just about keeping the lights on!https://www.linkedin.com/in/jonhathaway/https://hatech.io/https://www.linkedin.com/in/jarvis-mishler/https://twitter.com/hatechllc

Did you know that the JVM has 700+ configuration settings? Did you know that MongoDB performance can be improved by 50% just by tuning the right database and OS nobs? Every thought that slower I/O can actually speed up database transaction times?In this episode we invited Stefano Doni, CTO at Amakas.io, who gives us a new perspective on how to approach performance optimization for complex environments. Instead of manually tweaking nobs on all sorts of runtimes or services they developed a Goal-driven AI-engine that automatically identifies the optimal settings for any application as it is under load. Make sure to check out their website and white papers where they go into details about how their algorithms work, which metrics they optimize and how you can apply their technology into a continuous delivery processhttps://www.linkedin.com/in/stefanodoni/https://www.akamas.io/

Have you ever used USE? Have you ever wondered what differentiates a performance tester from a performance engineer? Want to know how to automate performance engineering into DevOps Pipelines?Twan Koot, Performance Engineer at Sogeti, is answering all these questions. We met him at the last Neotys PAC Event where he gave an in-depth look on metrics and enlightened us all with USE (a method from Netflix’s Brendan Gregg). In our conversation we explain what USE really is, how to apply it and how a good performance engineer needs to understand more than just response time!Links:Twan on linkedin - https://www.linkedin.com/in/twan-koot-a813a8b7/Twan's deck from Neotys PAC - https://www.neotys.com/performance-advisory-council/twan-kootTwans Video at Neotys PAC - https://www.youtube.com/watch?v=hV8wpkDUtyshttp://www.brendangregg.com/Brendan Gregg's home page - http://www.brendangregg.com/eBPF - https://prototype-kernel.readthedocs.io/en/latest/bpf/BCC - https://iovisor.github.io/bcc/

How many different continuous delivery pipelines do you have in your organization? Do you have dedicated teams that keep them up-to-date and constantly extend them with new tool integrations? Have you already built in capabilities for shadow, dark, blue/green or canary deployments? Is auto-mitigation and self-healing already on your internal pipeline roadmap? Sounds like a lot of manual work?Keptn (@keptnProject)– an open source enterprise-grade framework for shipping and running cloud-native applications – is going to eliminate the manual efforts in building, maintaining and extending pipelines. Alois Reitbauer, Head of the Dynatrace Innovation Lab, gives us the background on how keptn evolved, which cloud native best practices are implemented as core capabilities, how to contribute to this project and gives us a glimpse into where the journey is going. Visit the about page and join the community and make sure to deploy keptn on your own Kubernetes clusters by simply following the step-by-step guides.https:/

Nicki (@nicki_23) was bored in finance, started to learn .NET development on the side and eventually won 250k at a hackathon she used for her startup. Now she is a “Digital” Technical Evangelist at AWS and spreads her passion about Serverless through twitch and shares her code examples on githubTune in if you want to learn more about which things you should know about Serverless and Lambda. We chat about IAM permissions, timeouts, API Gateway and how a CI/CD Pipeline for Lambdas should look likehttps://twitter.com/nicki_23?lang=enhttps://www.twitch.tv/awshttps://github.com/kneekey23

Is Cloud Native just a synonym for Kubernetes? How to make sense of the sea of tools & frameworks that pop up daily? What can we learn from others that made the transformation and most of all: Where do we start?We got answer to all these and many more questions from Priyanka Sharma (@pritianka) – Dir. of Alliances at GitLab and Governing Board Member at CNCF (Cloud Native Computing Foundation). In her work, Priyanka has seen everything from small startups to large enterprises leveraging Cloud Native technology, tools and mindset to build, deploy & run better software faster. She advises to start incrementally and whatever you do in your transformation make sure to always focus on: Visibility (which leads to transparency), Easy of Collaboration (which increases productivity & creativity) and Setting Guardrails (this ensures you stay compliant & avoids common pitfalls).We ended the conversation around the idea of needing “Cloud Native Aware Developers” which can follow best practices or standard

The .NET Runtime – whether .NET Framework or .NET Core – provides many ways to optimize memory management. But they don’t come in the form of configuration switches as we know if from Java. While there are a handful of settings, the .NET Runtime favors a different approach: asking developers to write memory aware software that follows a couple of core memory aware principles and best practices.In this podcast we get to talk with Konrad Kokosa (@konradkokosa) – author of Pro .NET Memory Management. In his book he gives developers and operators great tips on how to optimize your .net applications and environments such as #1: start with proper monitoring; #2: reduce memory allocations; #3: well – for this and more you should check out Konrad’s book.Listen in to a great discussion with somebody that has been working very close with the .NET Engineering Teams over the past years and brings the internal secrets of .NET Memory Management to everyone out there that wants to write Memory Aware .NET Software!https://pr

Creating and maintaining test scenarios not only takes a lot of time, but means we are creating artificial test scenarios based on what we think users are going to do versus replicating real users behavior. In this episode we invited Thomas Rotté, one of our friends from https://probit.cloud, who solved these problems for their work at KBC Bank. Their solution is an AI that learns behavior of real user traffic, creates a probability model for most common user journeys and uses that model to create automation test scripts on the fly for automated, real user simulating test bots. We also learn how GDPR and other challenges influenced their solution and how they are now working with other tool vendors and enterprises to bring this technology to the market.

How to you scale a startup, a mid size company or an enterprise software organization? Can we learn from the Spartans or the Romans? And how can we explain DevOps to a Dummy?In this fun filled episode with Emily Freeman (@editingemily), Cloud Developer Advocate at Microsoft, we get answers to all these questions and get inspired to join Emily’s appearance at the upcoming devone.at conference in Linz, Austria where she dives deeper into how to successfully scale development organizations from startup to enterprise. Later in 2019 make sure to watch out for the written version of our discussion on DevOps for Dummies – Emily is using her writing skills to bring it to paper!https://emilyfreeman.io/

Kurt Aigner gave a session about managing hybrid system complexity, from the cloud to the mainframe and everything in between. He shares a few notes and tips in this discussion.

In this episode, Andi has a coffee and a chat with Dynatrace's Chief Product Officer Andreas Lehofer where they dig a little deeper into AI Ops Enhancements.

Gary Carr shares his experience with Dynatrace IaaS cloud support and a deep dive into how Dynatrace open AI provides intelligence into the capabilities and technologies of Azure, GCP and AWS.