u/ManningBooks

Hi all,

Stjepan from Manning here. The mods said it's fine if I post this here.

I wanted to share a new MEAP (early access) release we think will land well with people here: Quantization and Fast Inference by Kalyan Aranganathan: https://www.manning.com/books/quantization-and-fast-inference

Quantization and Fast Inference

A lot of ML deployment discussions still revolve around model quality first and infrastructure second. Then the bill shows up. Or latency becomes unacceptable. Or the model that worked fine on A100s suddenly needs to run somewhere much smaller.

This book focuses on the practical side of making models cheaper and faster without rebuilding them from scratch. It starts with quantization fundamentals and works its way through PTQ, QAT, runtime packaging, and deployment trade-offs that matter once you’re dealing with production constraints rather than benchmarks.

What I liked about the manuscript is that it doesn’t stop at “here’s INT8.” It gets into the annoying details people usually learn the hard way: activation outliers in LLMs, KV cache pressure, fake quantization workflows, straight-through estimators, and why some sub-8-bit formats behave very differently once you leave the paper and hit actual inference workloads.

There’s also a solid balance between theory and implementation. The derivations are there if you care about the math, but the book keeps returning to operational questions like memory bandwidth, latency, and deployment cost.

Since this is a MEAP release, the book is still being developed chapter by chapter, and readers get access to the manuscript as it evolves. We’ve found that ML books especially benefit from that process because readers often push authors toward clearer explanations and more relevant examples while the book is still in progress.

We’ve got 5 free ebook copies for the first 5 people who comment with their experience using quantization in production or research. Success stories, failed experiments, weird edge cases — all fair game.

If you’d rather grab it directly, we also put together a 50% discount code for the subreddit: MLKALYANARANGAN50RE

Curious what people here think the current pain point is with quantization workflows.

Accuracy collapse? Tooling fragmentation? Hardware-specific behavior? Something else entirely?

I’ll stick around for discussion, and I’m happy to bring the author in for questions if there’s interest.

Cheers,

Stjepan

Hi r/Pentesting ,

Stjepan from Manning here, and I wanted to share something we’ve been working on that feels very relevant to where offensive security is heading right now: AI Agents for Offensive Security by Mark Foudy: https://www.manning.com/books/ai-agents-for-offensive-security

The mods said it's fine if I post this here. I’ll keep it grounded in what matters for this sub.

AI Agents for Offensive Security

A lot of the AI + security discussion online is either hype or surface-level tooling. What this book tries to do is show how AI actually fits into day-to-day offensive workflows without pretending it replaces the human doing the work.

It walks through building agents that can:

• support recon and data collection without turning into blind automation
• Help with triage when you’re buried in findings
• assist in vulnerability discovery, especially in messy, real-world targets
• Generate structured reports that don’t need a full rewrite afterward

There’s also a big focus on how not to shoot yourself in the foot. Things like:

• keeping actions auditable (so you know what your agent actually did)
• putting guardrails around scope and authorization
• understanding where AI introduces risk instead of reducing it

The multi-agent pipelines part is interesting too. Instead of one “do everything” agent, the book breaks workflows into smaller pieces that pass artifacts between each other. Closer to how a real engagement works, just with some of the repetitive work offloaded.

Giveaway (keeping it simple):

• 5 free ebook copies
• First 5 people who comment with their experience (or skepticism) about using AI in pentesting workflows
• I’ll DM the winners

If you’d rather just grab it, we’ve got a 50% discount for the sub: PBFOUDY50RE

I’d actually like to hear where people stand on this.

Are you already using AI in engagements in any meaningful way? Not ChatGPT for quick commands, but something closer to workflow integration.

Or have you tried and backed off because it introduced more noise than signal?

Happy to discuss, and if there’s interest, I can bring the author in for a proper Q&A.

It feels great to be here. Thanks for having us.

Cheers,

Stjepan

Hi everyone,

I’m Stjepan from Manning, and with mods' approval, I wanted to share a book we’ve been working on: High Performance Unity Game Development by Nitzan Wilnai: https://www.manning.com/books/data-oriented-design-for-games

High Performance Unity Game Development

Before dropping the link and disappearing, I’ll explain why this might actually be useful here (and how it’s different from a lot of the free Unity material out there).

Most Unity content - including Unity’s own ebooks - focuses on how to use features. This book is more about how to think about performance from the ground up, especially when your project starts hitting limits.

It leans heavily on Data-Oriented Design (DOD). If you’ve ever:

• hit a wall with MonoBehaviours everywhere
• struggled to keep frame rates stable on lower-end devices
• or tried ECS and felt like it didn’t quite “click”

…this is the kind of material the book digs into.

It walks through building a full game while reshaping the architecture around data instead of objects. Arrays over hierarchies, systems over inheritance, fewer hidden costs. There’s also a lot of practical discussion around CPU behavior, memory layout, and why certain patterns break down as your game scales.

This isn’t tied only to Unity DOTS either. The ideas carry over even if you’re still working in a more traditional setup or doing 2D projects where performance bottlenecks show up differently (lots of entities, tight update loops, mobile constraints, etc.).

Giveaway (mods asked for clear terms, so here they are):

• Prize: 5 free ebook copies
• How to enter: Comment with your experience (or frustration) around performance in Unity — especially in 2D projects
• Eligibility: Anyone in the subreddit
• Deadline: 48 hours after this post goes live
• Winners: First 5 meaningful comments (not just “I’m in”)
• Note: This giveaway isn’t affiliated with or sponsored by Reddit

If you don’t want to rely on luck, we’ve also got a 50% discount code: PBWILNAI50RE

I’d actually like to turn this into a discussion rather than a drop-and-run:

Where do you typically start to notice performance issues in Unity2D?

Too many sprites? Physics? Update loops? Something else entirely?

Let me know.

It feels great to be here. Thanks for having us.

Cheers,

Stjepan

Hi r/Unity3D,

Posting with mod approval from Manning. I’ll try to make this worth your time and not just another promo post.

We recently published High Performance Unity Game Development by Nitzan Wilnai
https://www.manning.com/books/high-performance-unity-game-development

High Performance Unity Game Development

A lot of Unity’s official material (and most tutorials out there) focus on how to use the engine well. This book comes from a slightly different angle: how to structure your code so performance doesn’t fall apart later.

If you’ve ever:

• hit a wall trying to optimize something that “shouldn’t be slow”
• wrestled with MonoBehaviour-heavy architectures that got harder to extend over time
• looked at ECS/DOTS and thought “I get the idea, but how do I actually design around this?”

- then you’re already in the territory this book covers.

It’s centered around Data-Oriented Design (DOD). Not just “use arrays instead of objects,” but how thinking in terms of data layout changes the way you design systems. The book walks through building a game step by step (a survivor-style project), showing how decisions around data shape performance, memory access, and even how easy it is to add features later.

One thing that stood out to me is that it doesn’t treat ECS or DOD as magic fixes. It shows where they help, where they add complexity, and how to apply those ideas even if you’re not going all-in on DOTS.

That’s probably the biggest difference compared to Unity’s free ebooks: those are great for learning features and workflows; this one is more about why your architecture behaves the way it does when things scale.

I’m curious how people here are approaching performance right now:

• Are you sticking with classic OOP + optimizations when needed?
• Moving parts of your project to ECS/DOTS?
• Or avoiding that shift because of complexity/tooling concerns?

Would be great to hear what’s actually working for you in production or even in side projects.

Also, we’ve got 5 free ebooks to give away. First 5 people who comment with how they’re handling performance (or a problem they’re stuck on), I’ll send you a copy.

And if you want to grab it directly, you can use PBWILNAI50RE for 50% off.

It feels great to be here. Thanks for having us.

Cheers,

Stjepan