『52 Weeks of Cloud』のカバーアート

52 Weeks of Cloud

52 Weeks of Cloud

著者： Noah Gift
無料で聴く

このコンテンツについて

 A weekly podcast on technical topics related to cloud computing including: MLOPs, LLMs, AWS, Azure, GCP, Multi-Cloud and Kubernetes.2021-2024 Pragmatic AI Labs 数学 科学
エピソード
  • Plastic Shamans of AGI

    Plastic Shamans of AGI
    2025/05/21
    The plastic shamans of OpenAI🔥 Hot Course Offers: - 🤖 Master GenAI Engineering - Build Production AI Systems - 🦀 Learn Professional Rust - Industry-Grade Development - 📊 AWS AI & Analytics - Scale Your ML in Cloud - ⚡ Production GenAI on AWS - Deploy at Enterprise Scale - 🛠️ Rust DevOps Mastery - Automate Everything 🚀 Level Up Your Career: - 💼 Production ML Program - Complete MLOps & Cloud Mastery - 🎯 Start Learning Now - Fast-Track Your ML Career - 🏢 Trusted by Fortune 500 Teams Learn end-to-end ML engineering from industry veterans at PAIML.COM
    続きを読む 一部表示
    11 分
  • The Toyota Way: Engineering Discipline in the Era of Dangerous Dilettantes

    The Toyota Way: Engineering Discipline in the Era of Dangerous Dilettantes
    2025/05/21
    Dangerous Dilettantes vs. Toyota Way EngineeringCore ThesisThe influx of AI-powered automation tools creates dangerous dilettantes - practitioners who know just enough to be harmful. The Toyota Production System (TPS) principles provide a battle-tested framework for integrating automation while maintaining engineering discipline.Historical ContextToyota Way formalized ~2001DevOps principles derive from TPSCoincided with post-dotcom crash startupsDecades of manufacturing automation parallels modern AI-based automationDangerous Dilettante IndicatorsPromises magical automation without understanding systemsFocuses on short-term productivity gains over long-term stabilityCreates interfaces that hide defects rather than surfacing themLacks understanding of production engineering fundamentalsPrioritizes feature velocity over deterministic behaviorToyota Way Implementation for AI-Enhanced Development1. Long-Term Philosophy Over Short-Term Gains// Anti-pattern: Brittle automation scriptlet quick_fix = agent.generate_solution(problem, { optimize_for: "immediate_completion", validation: false});// TPS approach: Sustainable system designlet sustainable_solution = engineering_system .with_agent_augmentation(agent) .design_solution(problem, { time_horizon_years: 2, observability: true, test_coverage_threshold: 0.85, validate_against_principles: true });Build systems that remain maintainable across yearsEstablish deterministic validation criteria before implementationOptimize for total cost of ownership, not just initial development2. Create Continuous Process Flow to Surface ProblemsImplement CI pipelines that surface defects immediately:Static analysis validationType checking (prefer strong type systems)Property-based testingIntegration testsPerformance regression detectionBuild flow:make lint → make typecheck → make test → make integration → make benchmarkFail fast at each stageForce errors to surface early rather than be hidden by automationAgent-assisted development must enhance visibility, not obscure it3. Pull Systems to Prevent OverproductionMinimize code surface area - only implement what's neededPrefer refactoring to adding new abstractionsUse agents to eliminate boilerplate, not to generate speculative features// Prefer minimal implementationsfunction processData(data: T[]): Result { // Use an agent to generate only the exact transformation needed // Not to create a general-purpose framework}4. Level Workload (Heijunka)Establish consistent development velocityAvoid burst patterns that hide technical debtUse agents consistently for small tasks rather than large sporadic generations5. Build Quality In (Jidoka)Automate failure detection, not just productionAny failed test/lint/check = full system haltEvery team member empowered to "pull the andon cord" (stop integration)AI-assisted code must pass same quality gates as human codeQuality gates should be more rigorous with automation, not less6. Standardized Tasks and ProcessesUniform build system interfaces across projectsConsistent command patterns:make formatmake lintmake testmake deployStandardized ways to integrate AI assistanceDocumented patterns for human verification of generated code7. Visual Controls to Expose ProblemsDashboards for code coverageComplexity metricsDependency trackingPerformance telemetryUse agents to improve these visualizations, not bypass them8. Reliable, Thoroughly-Tested TechnologyPrefer languages with strong safety guarantees (Rust, OCaml, TypeScript over JS)Use static analysis tools (clippy, eslint)Property-based testing over example-based#[test]fn property_based_validation() { proptest!(|(input: Vec)| { let result = process(&input); // Must hold for all inputs assert!(result.is_valid_state()); });}9. Grow Leaders Who Understand the WorkEngineers must understand what agents produceNo black-box implementationsLeaders establish a culture of comprehension, not just completion10. Develop Exceptional TeamsUse AI to amplify team capabilities, not replace expertiseAgents as team members with defined responsibilitiesCross-training to understand all parts of the system11. Respect Extended Network (Suppliers)Consistent interfaces between systemsWell-documented APIsVersion guaranteesExplicit dependencies12. Go and See (Genchi Genbutsu)Debug the actual system, not the abstractionTrace problematic code pathsVerify agent-generated code in contextSet up comprehensive observability// Instrument code to make the invisible visiblefunc ProcessRequest(ctx context.Context, req *Request) (*Response, error) { start := time.Now() defer metrics.RecordLatency("request_processing", time.Since(start)) // Log entry point logger.WithField("request_id", req.ID).Info("Starting request processing") // Processing with tracing points // ... // Verify exit conditions if err != nil { metrics.IncrementCounter("processing_errors", 1) logger.WithError(err).Error("Request processing failed") } return resp, err}13. Make Decisions Slowly by ConsensusMulti-stage ...
    続きを読む 一部表示
    15 分
  • DevOps Narrow AI Debunking Flowchart

    DevOps Narrow AI Debunking Flowchart
    2025/05/16
    Extensive Notes: The Truth About AI and Your Coding JobTypes of AI

    • Narrow AI

      • Not truly intelligent
      • Pattern matching and full text search
      • Examples: voice assistants, coding autocomplete
      • Useful but contains bugs
      • Multiple narrow AI solutions compound bugs
      • Get in, use it, get out quickly

    • AGI (Artificial General Intelligence)

      • No evidence we're close to achieving this
      • May not even be possible
      • Would require human-level intelligence
      • Needs consciousness to exist
      • Consciousness: ability to recognize what's happening in environment
      • No concept of this in narrow AI approaches
      • Pure fantasy and magical thinking

    • ASI (Artificial Super Intelligence)

      • Even more fantasy than AGI
      • No evidence at all it's possible
      • More science fiction than reality
    The DevOps Flowchart Test

    1. Can you explain what DevOps is?

      • If no → You're incompetent on this topic
      • If yes → Continue to next question

    2. Does your company use DevOps?

      • If no → You're inexperienced and a magical thinker
      • If yes → Continue to next question

    3. Why would you think narrow AI has any form of intelligence?

      • Anyone claiming AI will automate coding jobs while understanding DevOps is likely:
        • A magical thinker
        • Unaware of scientific process
        • A grifter
    Why DevOps Matters
    • Proven methodology similar to Toyota Way
    • Based on continuous improvement (Kaizen)
    • Look-and-see approach to reducing defects
    • Constantly improving build systems, testing, linting
    • No AI component other than basic statistical analysis
    • Feedback loop that makes systems better
    The Reality of Job Automation
    • People who do nothing might be eliminated
      • Not AI automating a job if they did nothing
    • Workers who create negative value
      • People who create bugs at 2AM
      • Their elimination isn't AI automation
    Measuring Software Quality
    • High churn files correlate with defects
    • Constant changes to same file indicate not knowing what you're doing
    • DevOps patterns help identify issues through:
      • Tracking file changes
      • Measuring complexity
      • Code coverage metrics
      • Deployment frequency
    Conclusion
    • Very early stages of combining narrow AI with DevOps
    • Narrow AI tools are useful but limited
    • Need to look beyond magical thinking
    • Opinions don't matter if you:
      • Don't understand DevOps
      • Don't use DevOps
      • Claim to understand DevOps but believe narrow AI will replace developers
    Raw Assessment
    • If you don't understand DevOps → Your opinion doesn't matter
    • If you understand DevOps but don't use it → Your opinion doesn't matter
    • If you understand and use DevOps but think AI will automate coding jobs → You're likely a magical thinker or grifter

    🔥 Hot Course Offers:
    • 🤖 Master GenAI Engineering - Build Production AI Systems
    • 🦀 Learn Professional Rust - Industry-Grade Development
    • 📊 AWS AI & Analytics - Scale Your ML in Cloud
    • ⚡ Production GenAI on AWS - Deploy at Enterprise Scale
    • 🛠️ Rust DevOps Mastery - Automate Everything
    🚀 Level Up Your Career:
    • 💼 Production ML Program - Complete MLOps & Cloud Mastery
    • 🎯 Start Learning Now - Fast-Track Your ML Career
    • 🏢 Trusted by Fortune 500 Teams

    Learn end-to-end ML engineering from industry veterans at PAIML.COM
    続きを読む 一部表示
    11 分

52 Weeks of Cloudに寄せられたリスナーの声

カスタマーレビュー：以下のタブを選択することで、他のサイトのレビューをご覧になれます。

Audible.co.jp

Amazon.co.jp
レビューはまだありません。