Skip to main content
Around IT in 256 seconds

Around IT in 256 seconds

By Tomasz Nurkiewicz
Podcast for developers, testers, SREs... and their managers.
I explain complex and convoluted technologies in a clear way, avoiding buzzwords and hype.
Never longer than 4 minutes and 16 seconds.
Because software development does not require hours of lectures, dev advocates' slide decks and hand waving.
For those of you, who want to combat FOMO, while brushing your teeth.
256 secondsis plenty of time.
If I can't explain something within this time frame, it's either too complex, or I don't understand it myself.

Hosted by Tomasz Nurkiewicz. Java Champion, CTO, trainer, O'Reilly author, blogger.
Listen on
Where to listen
Apple Podcasts Logo

Apple Podcasts

Breaker Logo


Google Podcasts Logo

Google Podcasts

Overcast Logo


RadioPublic Logo


Spotify Logo


Currently playing episode

#12: Continuous integration, delivery and deployment

Around IT in 256 seconds

#19: GraalVM
GraalVM is a set of tools that aim to improve the performance and interoperability of Java Virtual Machine. Taking advantage of GraalVM not only makes your apps run faster. It also allows running different languages like JavaScript or Python with superb speed. GraalVM consists of quite a few projects, so let's dive in. The most groundbreaking technology is the JIT compiler. To recap, JIT is responsible for translating abstract bytecode into low-level machine code. JIT is the reason why Java is actually quite fast these days. Your code is compiled behind the scenes into heavily optimized CPU instructions. Unfortunately, this wonderful piece of software was buried deeply in Java VM.  The JIT codebase in C++ turned out to be too complex to maintain anymore. So someone thought: what if we rewrite JIT compiler in Java? Sounds crazy. But as a matter of fact, JIT is essentially a pure function that takes bytecode as input and returning machine code as output. Byte array in, byte array out. That's how GraalVM was born. Now you can plug-in a JIT compiler written in Java to a JVM. Suddenly the codebase became much more maintainable and developer friendly. GraalVM's JIT compiler quickly outperformed legacy JIT compiler. Essentially it is now much easier to write optimized machine code generation. But it turned out this was just the beginning. Read more: Get the new episode straight to your mailbox:
October 19, 2020
#18: JIT - Just-in-time compilation
Source code can then be executed in two ways. Language implementations in general either interpret or compile it. In order to run an interpreted program, you need one extra binary: an interpreter. Interpretation is simple: you read source code line by line and execute it. The compilation is much harder. A special program called a compiler reads your source code ahead of time (AOT) and translates it into machine code. After this translation your program is standalone. You don't need a compiler to run it. Only you and your CPU. Turns out this distinction is not that clear at all these days. Almost every language implementation performs compilation behind the scenes. And many languages that have a compiler produce code that needs an interpreter anyway. What? Read more: Get the new episode straight to your mailbox:
October 12, 2020
#17: BPM: Business process modeling
[...] All of this complexity is somewhat hidden with BPM framework. First of all the process is first drawn. Using a special notation known as BPMN. This is actually quite natural. You use arrows to show how insurance claim changes state over time - and why. Then the diagram is translated into fairly standard XML. Now those pesky developers need to fill in the gaps. I mean, writing code that does some logic. For example sending an SMS when a claim enters a certain state. Or transferring money when a transition happens from one state to another. [...] Read more: Get the new episode straight to your mailbox:
October 6, 2020
#16: Akka
Akka is a toolkit for building highly scalable, concurrent applications. It's written in Scala and based on the ideas from Erlang. Its approach to achieve concurrency is quite radical. Rather than mutexes, semaphores and shared memory, Akka uses so-called _actor model_. Actor is a small, stateful object that doesn't expose traditional methods. Instead, actors send and receive asynchronous messages with each other. There is no other way to interact with an actor. If you want an actor to do something or give you some information, message passing is the only way. Send a message, actor will receive it at some point in time, consume it and optionally send a response back.  Read more: Get the new episode straight to your mailbox:
September 22, 2020
#15: Mutation testing
Imagine I wrote a script that takes your codebase and removes a random line. Fairly simple. Or maybe some more subtle change, like replacing plus with minus operator? Or switching `x` and `y` parameters with each other? OK, so now my script builds your project. Most of the time it will fail the compilation or test phase. But what if the build succeeds? Well, apparently your test suite is not covering some lines? OK, but what if my script only removes or alters lines covered by tests? How is it possible that the build still succeeds? Turns out your tests aren't as good as you think. And I just described mutation testing that discovers that. Read more: Get the new episode straight to your mailbox:
September 14, 2020
#14: Static, Dynamic, Strong and Weak Type Systems
When choosing or learning a new programming language, type system should be your first question. How strict is that language when types don't really match? Will there be a conservative, slow and annoying compiler? Or maybe a fast feedback loop, often resulting in crashes at runtime? And also, is the language runtime trusting you know what you are doing, even if you don't? Or maybe it's babysitting you, making it hard to write fast, low-level code? Believe it or not, I just described static, dynamic, weak and strong typing. Read more: Get the new episode straight to your mailbox:
August 31, 2020
#13: Cassandra
Cassandra is an open-source NoSQL database. It's heavily optimized for writes, but also has intriguing read capabilities. Cassandra has near-linear scalability. In terms of CAP theorem it favours consistency over availability. Interestingly, despite NoSQL label, Cassandra tables have strict schema. Also, Cassandra Query Language is similar to SQL. Read more: Get the new episode straight to your mailbox:
August 18, 2020
#12: Continuous integration, delivery and deployment
Typically, more than one developer is working on the same codebase. How do they share their work? The simplest approach is a common Dropbox folder. This has several drawbacks, mainly we risk breaking other's work with our half-done features. So we come up with version control systems. Read more: Get new episode straight to your mailbox:
August 11, 2020
#11: MapReduce
MapReduce is a programming model for processing large amounts of data. It works best when you have a relatively simple program, but data is spread across thousands of servers. MapReduce was invented and popularized by Google. I'll talk about MapReduce in general and Hadoop in particular. Read more: Get new episode straight to your mailbox:
August 4, 2020
#10: HTTP protocol
HTTP protocol is fundamental to the Internet. It's a simple request-response protocol where the request is initiated by the client, typically a web browser. Read more: Get new episode straight to your mailbox:
July 27, 2020
#9: Retrying failures
I find it quite fascinating how many failures in complex systems could be avoided if we simply... tried again. So how so you retry effectively, so that your systems are much more fault-tolerant and less brittle? Read more: Get new episode straight to your mailbox:
July 21, 2020
#8: Kafka's design
Kafka is not a message broker. However, it can be used as such very effectively. Instead, I'd like to think about as a very peculiar database. A database where inserts are insanely fast and sequential reads are preferred and very fast as well. In this episode I am focusing on the architecture and internals of Kafka. The best way to understand Kafka is by examining how it works. Read more: Get new episode straight to your mailbox:
July 14, 2020
#7: Speed of light
Speed of light is not as abstract to us, software engineers, as you might think. If you are deploying to the cloud or if you want to squeeze every bit of performance in your app, speed of light holds you back. Light travels at an unbelievable speed of three hundred thousand kilometers per second. That's more than 7 times around the globe in one second. Is this relevant in our industry?  Read more: Get new episode straight to your mailbox:
July 6, 2020
#6: Little's law
Little's law is an astounding equation that's dead simple, yet it can bring an amazing insight into what your distributed system is capable of. Read more: Newsletter: More resources: * Little's law: * John Little: * Node.js and CPU intensive requests: * My talk where I mention Little's law (from 23:03:
June 30, 2020
#5: asm.js and WebAssembly
Read more: Newsletter: More resources: * asm.js: * WebAssembly: * Compiling C/C++/Rust/... to asm.js via LLVM backend: * Quake in the browser (asm.js): * Unity Engine in the browser (WebAssembly):
June 16, 2020
#4: Serverless
Read more: Newsletter: 4th edition of the newsletter, apart from transcript, contains GraphQL scalability tricks, enjoy! More resources: * AWS Lambda: * Google Cloud Functions: * Azure Functions: * Spring Cloud Function:
June 8, 2020
#3: GraphQL
Read more: Newsletter: More resources: Official GraphQL website: Curated collection of resources: GitHub's API explorer using GraphQL: Facebook's API explorer using GraphQL: Visual GraphQL explorer for any API: A series of my blog posts about GraphQL in Java:,,
June 2, 2020
#2: Service Mesh
Notable implementations of service mesh: * * More details: * What's a service mesh? And why do I need one? ( * What's a service mesh? ( * InfoQ ( * Service Mesh Landscape ( * Service Mesh Comparison ( Read more at: Most episodes are originally much longer. If you wish to hear full, director's cut version, check out my mailing list: I will also notify you about new episodes and add some extra content like transcripts. Suggest your topics:
May 26, 2020
#1: Circuit Breaker
Circuit breaker is a design pattern that prevents cascading failures in distributed systems. More details: and Circuit breaker implementations: * (Java) * (.NET) * (Go) * (Scala/Akka) * (JavaScript) This episode was originally twice as long. If you wish to hear full, director's cut version, check out my mailing list: I will also notify you about new episodes and add some extra content. Suggest your topics:
May 12, 2020
#0: Meta
I explain software development in no more than 4 minutes and 16 seconds. Notifications of new episodes: User voice: suggest topics: Which programming languages count from 1: Background music from
April 27, 2020