Rookout Blog

There are countless tools that are available to developers. With all these options, how do you choose what’s best? Going about choosing these tools is no easy feat, so we thought we could make it a bit easier for you as you do.

Why would you go about running Jenkins on top of Kubernetes? The reasons can vary anywhere from maintenance work to maintenance costs to highly customizable CI/CD processes. Here are some insights to achieve a smooth deployment experience.

When looking at our tech stack and architecture, and specifically in regards to the “machine”, a variety of challenges can be seen. In all cases, the “machine” isn’t enough, and there is always one other thing that’s missing to factor into the equation.

The rise of new software techniques such as microservices or serverless has necessitated taking a leap of faith to try and adopt new means to debug, such as remote debugging.

How do engineers often make poor choices when it comes to their very own software? Read about the choice between data and code, the software it affects, and how to get it right.

In the age of discovery, navigators changed the world. Nowadays, in the age of data, developers are the new navigators. Their happiness is the key to the success of modern business- but how do we keep them happy?

The metaphor of software viruses to biological ones is deeply ingrained, easily seen in the fact that biological viruses are at least the namesake, if not the inspiration for computer viruses. Can we take this analogy and reapply it in reverse? We are going to try and explore that in this thought experiment.

The change to a distributed team from a monolith team can be difficult. With the future unknown, it's important to analyze what this means for team leaders everywhere.

How do you know deployment is the bottleneck? To be blunt, deploying new code is always the bottleneck.

In tech, gender is irrelevant; innovation is the name of the game. These strong, brilliant, brave, charismatic, humorous, and intelligent women are laying the stones for the road to the future of technology.

Technology has advanced rapidly, but the ease of debugging has not. With the introduction of serverless computing, the way enterprises are designed and how they build their production applications was changed.

I have had the great pleasure of joining the Rookout team. They have become a true leader in the devops space, bringing production grade debugging to everyone. Looking forward to the future!

Today, service architecture is becoming increasingly complex with the explosion of new software techniques such as microservices. Here are some best practices for debugging that you can keep in mind that are specific to your organization’s architectural model: monolith, or microservices.

A gift for you this Valentine's day: groove out to Rookout's developer playlist. Compiled with all the best songs our devs listen to while they code, just for you!

Even better than traveling to Barcelona is traveling to a tech conference in Barcelona. Here are 3 notable trends I noticed during my time at Cisco Live Europe 2020.

Race conditions are bugs commonly found in asynchronous systems and can be quite tricky to deal with. Luckily, there’s now a full guide to help you out.

The Force is strong with our ungated Sandbox. Here’s why we decided to open one, and what Star Wars had to do with it.

The ability to debug in production is a valuable tool that allows the developer to find the issue and fix it while the system is still running.

Software Monitoring has come a long way since IT departments began digitalizing internal processes. Where is it headed next?

When data is the new oxygen, deadlocks and bottlenecks can no longer be tolerated. Here’s a new perspective on who should hold the keys to data pipelines.

Imagine you could time travel. When would you go? What would you do? That's what happened to me just before Christmas. Here's how the adventure unfolded.

Dear Dev Santa, how are things at the north pole? Hope you and Mrs. Santa have good wifi reception, and that the elves aren’t driving you crazy with their electric scooters and kombucha tea.

This year’s KubeCon proved once again that the industry focus on improving and simplifying dev workflows is a major priority for most organizations.

For your customers, you need to be both: a cool, fast, innovative startup and have a perfect product with the level of reliability of a big corporate IT.

In honor of KubeCon, I hand-picked the top-3 mistakes you can make when moving to K8s. These are based on our own experience as a dev-facing company on a K8s journey, as well as the experience of our customers.

Here's how you can use Jenkins X and Rookout to dynamically debug and extract data from a running Node.js microservice, without breaking or redeploying.

Java agents can be a powerful tool. Here's how you can simplify the deployment of Java agents on K8s without major changes to existing services.

Going through the compliance process is no small undertaking, and can have a significant impact on your engineering and business velocity down the line.

Log aggregation systems are awesome. They truly are. But why, oh why, do they have to be so expensive? Here are some tips to cut the costs.

If you are a developer, a tech lead or an engineering manager, look out for these signs to prevent debugging from becoming a productivity killer.

Becoming compliant takes time. Here are the 3 steps we've taken to make our SaaS company's journey towards SOC 2 Type 2 certification much quicker.

Using Rookout, you can stream your logs directly to your favorite log management system. No need to install libraries, or add code snippets. Here's how.

You’re debugging a local app in your favorite IDE. You set a breakpoint, the code stops, you check the local variables and you step in again (or try to)...

Value can be delivered and systems changed without a single line of code being written. So should we rely on "code changes" as a DevOps KPI?

Fear of Missing Out on log lines and the data they comprise is the main motivator behind setting log lines for each line of code. But can we overcome it?

Debugging other people’s legacy code is the worst. Learn how you can use empathy, context switching, and a proven process to kill bugs with kindness.

The dread of every experienced developer, Heisenbugs used to be rare nightmares. With the rise of distributed systems, they're now becoming more widespread.

What makes maintaining modern production so hard? And what is the difference between being good and being bad at dev-on-call? Let’s dive in and see.

Why do we need good, informative logs? How can we write them well enough? And what does the future hold for logging technologies?

Reproducing the state of an error in K8s is frustrating. Here are the existing methods for debugging Kubernetes apps locally and remotely, in production.

With Rookout and its non-breaking breakpoints, data scientists can now instantly observe the behavior of ML/AI models throughout their lifecycle.

Data lets you expand your mind and see into the future. To grow your product, you'll have to find ways to harvest this precious yet addictive resource.

The time has come for a new generation of source control that wasn’t purely designed for open-source projects, C and the Linux kernel.

Working on a remotely-developed microservices app? Here are the best available tools to help you debug it, along with their key strengths and weaknesses.

When should you develop in a cloud environment? What issues should you consider when establishing what you need and ways to provision it?

The journey of naming a DevOps company can take you to surprising destinations. Here's our story and what we've learned roaming the jungles of name-ideas.

Developing microservices locally: the pros, the cons and some tools that will help you make local microservices dev quicker, easier and more robust.

How do microservices interact with the dev cycle and environment configuration? And how can we develop them more efficiently? First post in a 4-part series.

Happy engineers are more productive and make companies more profitable. But should DevOps be in charge of developer happiness? Let's break it down.

Debugging cloud-native apps is like going through multiple haystacks that keep on moving. But this time, you’re not even sure the needle exists.

What if there was a show that could capture the drama of developing, testing and debugging just as House MD captured the drama of diagnosis and treatment?

DevTech marketing isn’t blue sky: In fact, it’s quite crowded. But there’s still room to innovate and do work that is refreshing. Here's what I learned.

Replacing Kubernetes ingresses is a tricky and time-consuming process, but we did it anyway. Find out our 4 reasons for moving from nginx to Traefik.

Legend says it's possible to open a Perfect Bug. A bug that no developer will close as “description unclear/does not reproduce”; A bug all devs dream of.

Hybrid systems are a key aspect of technology today, and they are here to stay. But what will the future of serverless and microservices bring?

Last year I made a resolution to work more on my pet project. Write some code to make the world a better place. Like all resolutions, it was hard to keep...

With so many CI-as-a-service solutions these days, why in the world did we choose Jenkins? Find out Rookout's top reasons for still using Jenkins in 2019

Installing a Java Agent and using it to instrument the customer’s JVM doesn’t have a simple, straightforward implementation. Or so we thought...

As an entrepreneur and the CTO of a young startup, keeping a close eye on the product is at the top of my priorities.In this blog post, I will get you into my stack and share the list of monitoring tools I’m using on a daily basis.

The cost of managing microservices and the dependencies between them increase exponentially as their numbers rise. But things don't have to be complicated.

Thinking I'd never debug again, I was willing to leave my mechanical keyboard and geeky T-shirts behind. And then I met The One.

With most companies that are interested in serverless just taking their first baby steps with the technology, ServerlessDays Milan was a great opportunity to listen to early adopters and industry leaders and learn how to make your path to serverless a smooth one.

Whether you're savvy or newbie, these carefully chosen sessions can help you do well with K8S and open your mind to new microservices stack ideas.

3 surprising lessons for developers on how to benefit from the holiday season and maximize their efficiency during code freeze periods.

An engineer from 20 years ago would be completely baffled by modern servers in the cloud but would recognize a current IDE or debugger in seconds. By more effectively connecting tools to one another, creating better workflows on top of them, and finding true agility in data collection and observability, we can bridge the gap

Serverless debugging is a big issue and lots of companies rise to the challenge with local and production debugging solutions.

During office hours, when things are calm, a rubber duck may be enough, but when production is broken and the slack channel is screaming, I need a bit more than that. I need a debugging friend.

How to use distributed tracing with Jaeger. Download our slides and follow the demo guide. Contact us for more details.

Time to recovery matters! Do you still count on your users to report on bugs and what is the real cost of bugs in production?

5 practical lessons on how to design a product for developers to love

Follow the quick guide of a super-handy hack for those times when you need to build a local native extension.

A guide to automating your TLS endpoints in 15 minutes of work, with the help of a few open-source tools.

Rookout offers a remote live debugging solution that provides full visibility and code context from the live Electron app.

While maintaining and even creating new Java Application Servers systems makes business sense, deploying and especially debugging & monitoring the systems is a whole other matter. Delve into the different Java debugging methods and learn which is best for you.

It all started when I was testing Rookout on Docker (with Alpine and Python). Rookout is a new approach to data collection and pipelining from live code. We basically allow developers to request with few clicks any piece of data and view it on their machine regardless of their framework, cloud, and environment.

A genius friend of mine used to say - “Just do bugless oriented programming- when you code, if you see you’re about to write a bug- simply don’t - it saves a lot of time”. As bugless oriented remains a concept for gods, we mere mortals better find other practical approaches that actually work.

Devs have been seeking advice online from time immemorial. But why do we sometimes refuse to ask for help when we need it the most?

Earlier in my career as a dev team leader, I personally refused to adopt Jira. So what changed? Why choose it now as a CTO and co-founder of a startup?