Podcasts about Concurrency

In this episode of PodRocket, Dev Agrawal, dev advocate and developer, talks about building efficient asynchronous UIs, the challenges and solutions for handling complex state management, utilizing React and Solid frameworks, and the potential of suspense boundaries and transitions in modern web development. Links https://devagr.me https://github.com/devagrawal09 https://www.linkedin.com/in/dev-agrawal-88449b157 https://medium.com/@devagrawal09 https://www.youtube.com/channel/UCDXzM8ijdxkVA6NbQiQCKag https://x.com/devagrawal09 https://events.codemash.org/2025CodeMashConference#/agendaday=4&lang=en&sessionId=76186000004278631&viewMode=2 We want to hear from you! How did you find us? Did you see us on Twitter? In a newsletter? Or maybe we were recommended by a friend? Let us know by sending an email to our producer, Emily, at emily.kochanekketner@logrocket.com (mailto:emily.kochanekketner@logrocket.com), or tweet at us at PodRocketPod (https://twitter.com/PodRocketpod). Follow us. Get free stickers. Follow us on Apple Podcasts, fill out this form (https://podrocket.logrocket.com/get-podrocket-stickers), and we'll send you free PodRocket stickers! What does LogRocket do? LogRocket provides AI-first session replay and analytics that surfaces the UX and technical issues impacting user experiences. Start understand where your users are struggling by trying it for free at [LogRocket.com]. Try LogRocket for free today.(https://logrocket.com/signup/?pdr) Special Guest: Dev Agrawal.

In this episode of the Modern Web Podcast, hosts Rob Ocel and Danny Thompson sit down with Mariano Cocirio, Staff Product Manager at Vercel, to discuss Fluid Compute, a new cloud computing model that blends the best of serverless scalability with traditional server efficiency. They explore the challenges of AI workloads in serverless environments, the high costs of idle time, and how Fluid Compute optimizes execution to reduce costs while maintaining performance. Mariano explains how this approach allows instances to handle multiple requests efficiently while still scaling to zero when not in use. The conversation also covers what developers need to consider when adopting this model, the impact on application architecture, and how to track efficiency gains using Vercel's observability tools.Is Fluid Compute the next step in the evolution of serverless? Is it redefining cloud infrastructure altogether?Keypoints Fluid Compute merges the best of servers and serverless – It combines the scalability of serverless with the efficiency and reusability of traditional servers, allowing instances to handle multiple requests while still scaling down to zero. AI workloads struggle with traditional serverless models – Serverless is optimized for quick, stateless functions, but AI models often require long processing times, leading to high costs for idle time. Fluid Compute solves this by dynamically managing resources. No major changes required for developers – Fluid Compute works like a standard Node or Python server, meaning developers don't need to change their code significantly. The only consideration is handling shared global state, similar to a traditional server environment. Significant cost savings and efficiency improvements – Vercel's observability tools show real-time reductions in compute costs, with some early adopters seeing up to 85% savings simply by enabling Fluid Compute.Chapters0:00 – Introduction and Guest Welcome1:08 – What is Fluid Compute? Overview and Key Features2:08 – Why Serverless Compute Struggles with AI Workloads4:00 – Fluid Compute: Combining Scalability and Efficiency6:04 – Cost Savings and Real-world Impact of Fluid Compute8:12 – Developer Experience and Implementation Considerations10:26 – Managing Global State and Concurrency in Fluid Compute13:09 – Observability Tools for Performance and Cost Monitoring20:01 – Long-running Instances and Post-operation Execution24:02 – Evolution of Compute Models: From Servers to Fluid Compute29:08 – The Future of Fluid Compute and Web Development30:15 – How to Enable Fluid Compute on Vercel32:04 – Closing Remarks and Guest Social Media InfoFollow Mariano Cocirio on Social Media:Twitter:https://x.com/mcocirioLinkedin:https://www.linkedin.com/in/mcocirio/Sponsored by This Dot:thisdot.co

Bienvenue dans le deux-cent-quatre-vingt-huitième épisode de CacaoCast! Dans cet épisode, Philippe Casgrain et Philippe Guitard discutent des sujets suivants: Bambu Lab - La controverse CotEditor - Éditeur en code source AppIconKit - Pour que vos utilisateurs changent l'icône de votre application AutoDock - Cachez votre dock en fonction de la taille de vos écrans Swift concurrency - Un glossaire Ecoutez cet épisode

Matt Masicotte comes on the show to clear up all our misconceptions about concurrency in Swift 6.

Part 2 of our chat with Donny - we discuss the job market, AI, Vision Pro, and of course Swift UI.GuestDonny WalsDonny Wals

Donny comes on yet again to give his thoughts on 2024 - Swift Data, Swift Testing and Swift Macros while we mourn the death of Combine.GuestDonny WalsDonny Wals

Fredrik talks to Dejan Milicic about software development - understanding, methods, and stories. We start by talking about encapsulation of knowledge and the essential software in organizations. Almost every organization should - it can be argued - be developing software that solves their unique problems, and yet so many outsource so much of their knowledge encapsulation. Oh, and we can never completely encapsulate our knowledge in code either, so all the more reason to keep people who actually know what the code does and why around. Dejan tells us about his way to Ravendb and a developer relations role - and how you can craft your own job, stepping suitably outside of your comfort zone along the way. We also talk about shortening attention spans, daring to dig down a bit and find out about the context of things. Like the second sentence of some oft-repeated quote. Prohibit bad things, but help automate doing good things and avoid doing the bad things completely. Dejan shares some database backstories - why would someone want to build one more database? Specifically, what lead to the creation of Ravendb? And the very strong opinions which have been built into it. Avoiding falling into marketing-driven development. After that, we drift into talking about processes and how we work. Every organization is unique - which strongly speaks against adapting the “best practices” and methodologies of others. Or keeping things completely the same for too long. Innovation is also about doing what other people are not doing. Why is concurrency still hard? The free lunch has been over for twenty years! Functional programming and immutability offer ways forward, why aren’t these concepts spreading even more and faster? We get right back to understanding more context when Dejan discusses how few of us seem to have understood, just for example, the L in SOLID. Dive deeper, read more, and you will find new things and come up with new ideas. Finally, Dejan would like to see software development becoming just a little bit more mathematical. So that things can be established, verified and built on in a different way. Thank you Cloudnet for sponsoring our VPS! Comments, questions or tips? We a re @kodsnack, @tobiashieta, @oferlund and @bjoreman on Twitter, have a page on Facebook and can be emailed at info@kodsnack.se if you want to write longer. We read everything we receive. If you enjoy Kodsnack we would love a review in iTunes! You can also support the podcast by buying us a coffee (or two!) through Ko-fi. Links Dejan Ravendb Informatics Domain-driven design Event sourcing Data is worthless - said in episode 601 Developer relations Nosql databases Jack of all trades Jimmy - who introduced Fredrik to Dejan at Øredev 2024 Hibernate Relational databases Oren Eini - creator of Ravendb Antipatterns n+1 Couchbase Scrum Agile software development The Toyota approach The Scrum guide Unison programming language - VC funded Dr. Dobb’s journal The free lunch is over Concurrency SOLID Liskov substitution principle Repositories on top Unitofwork are not a good idea - by Rob Conery Elm Titles A mathematician turned software developer Coding, but without deadline Saturated with software development Encapsulation of knowledge A bit surreal Accept people as they are There’s a second line Professional depression Prevented, not diagnosed The pipeline kind of thinking Frustration-driven development (You shouldn’t be) Punished for being successful The largest company of his or her life so far Optimized for maintaining the status quo Wash away all the context Manager of one The proverbial Jira Substantial content Methods of moving forward

Zack Kayser and Ethan Gunderson, Software Engineers at Cars Commerce, join the Elixir Wizards to share their expertise on telemetry and observability in large-scale systems. Drawing from their experience at Cars.com—a platform handling high traffic and concurrent users—they discuss the technical and organizational challenges of scaling applications, managing microservices, and implementing effective observability practices. The conversation highlights the pivotal role observability plays in diagnosing incidents, anticipating system behavior, and asking unplanned questions of a system. Zack and Ethan explore tracing, spans, and the unique challenges introduced by LiveView deployments and WebSocket connections. They also discuss the benefits of OpenTelemetry as a vendor-agnostic instrumentation tool, the significance of Elixir's telemetry library, and practical steps for developers starting their observability journey. Additionally, Zack and Ethan introduce their upcoming book, Instrumenting Elixir Applications, which will offer guidance on integrating telemetry and tracing into Elixir projects. Topics Discussed: Cars.com's transition to Elixir and scaling solutions The role of observability in large-scale systems Uncovering insights by asking unplanned system questions Managing high-traffic and concurrent users with Elixir Diagnosing incidents and preventing recurrence using telemetry Balancing data collection with storage constraints Sampling strategies for large data volumes Tracing and spans in observability LiveView's influence on deployments and WebSocket behavior Mitigating downstream effects of socket reconnections Contextual debugging for system behavior insights Observability strategies for small vs. large-scale apps OpenTelemetry for vendor-agnostic instrumentation Leveraging OpenTelemetry contrib libraries for easy setup Elixir's telemetry library as an ecosystem cornerstone Tracing as the first step in observability Differentiating observability from business analytics Profiling with OpenTelemetry Erlang project tools The value of profiling for performance insights Making observability tools accessible and impactful for developers Links Mentioned https://www.carscommerce.inc/ https://www.cars.com/ https://hexdocs.pm/telemetry/readme.html https://kubernetes.io/ https://github.com/ninenines/cowboy https://hexdocs.pm/bandit/Bandit.html https://hexdocs.pm/broadway/Broadway.html https://hexdocs.pm/oban/Oban.html https://www.dynatrace.com/ https://www.jaegertracing.io/ https://newrelic.com/ https://www.datadoghq.com/ https://www.honeycomb.io/ https://fly.io/phoenix-files/how-phoenix-liveview-form-auto-recovery-works/ https://www.elastic.co/ https://opentelemetry.io/ https://opentelemetry.io/docs/languages/erlang/ https://opentelemetry.io/docs/concepts/signals/traces/ https://opentelemetry.io/docs/specs/otel/logs/ https://github.com/runfinch/finch https://hexdocs.pm/telemetry_metrics/Telemetry.Metrics.html https://opentelemetry.io/blog/2024/state-profiling https://www.instrumentingelixir.com/ https://prometheus.io/ https://www.datadoghq.com/dg/monitor/ts/statsd/ https://x.com/kayserzl https://github.com/zkayser https://bsky.app/profile/ethangunderson.com  https://github.com/open-telemetry/opentelemetry-collector-contrib Special Guests: Ethan Gunderson and Zack Kayser.

AJ (Alykhan Jetha), CEO and CTO of Marketcircle, joins the Elixir Wizards to share his experience building and evolving Daylite, their award-winning CRM and business productivity app for Apple users. He details his experiences as a self-taught programmer and how Marketcircle has navigated pivots, challenges, and opportunities since its founding in 1999. AJ explains why they migrated Daylite's backend to Elixir, focusing on their sync engine, which demands high concurrency and fault tolerance. He highlights how Elixir has improved performance, reduced cloud costs, and simplified development with its approachable syntax and productive workflows. The conversation also touches on the technical hurdles of deploying native apps for Apple devices and the potential for integrating new technologies like LiveView Native to streamline cross-platform development. For technical founders, AJ emphasizes the importance of leveraging your strengths (“superpowers”), staying deeply connected to the development process, and finding stability in tools like Elixir amidst a rapidly evolving tech ecosystem. He also shares Marketcircle's roadmap for migrating more customers to Elixir-powered systems and explores the potential for new features in their native apps. Tune in for insights on building resilient systems, navigating technical and business challenges, and how Elixir is shaping Marketcircle's future. Topics discussed in this episode: AJ's journey as a self-taught programmer and entrepreneur Marketcircle's evolution since 1999 and lessons from their pivots Daylite's growth as a flagship product for Apple users Migrating to Elixir for high concurrency and fault tolerance How Elixir improved performance and reduced cloud costs The simplicity of Elixir and its impact on developer onboarding Challenges in managing a growing microservices architecture Insights into deploying native apps for the Apple ecosystem Exploring LiveView Native for future cross-platform development Advice for technical founders: leveraging your superpowers Staying connected to development to maintain system understanding The role of Elixir in improving development efficiency and stability Planning gradual customer migrations to an Elixir-powered backend Potential new features for Daylite's native apps Benefits of collaboration with the Elixir community #ElixirMullet -- native app in the front, Elixir in the back Navigating a rapidly evolving tech ecosystem as a founder Leveraging Elixir to future-proof Marketcircle's systems Balancing technical and business priorities in a startup environment AJ's thoughts on the future of Elixir in powering business tools Links mentioned: https://www.marketcircle.com/ Daylite.app https://www.nextcomputers.org/ https://www.digitalocean.com/ Python Async https://docs.python.org/3/library/asyncio.html https://github.com/sinatra/sinatra https://github.com/dependabot https://kafka.apache.org/ https://www.djangoproject.com/ https://github.com/socketry/falcon https://github.com/puma/puma https://www.swift.org/blog/announcing-swift-6/ https://en.wikipedia.org/wiki/Async/await https://www.ffmpeg.org/ https://www.sqlite.org/ https://github.com/commanded/commanded https://pragprog.com/titles/khpes/real-world-event-sourcing/ https://en.wikipedia.org/wiki/ShipofTheseus https://reactnative.dev/ https://www.electronjs.org/ https://en.wikipedia.org/wiki/WebOS https://www.linkedin.com/in/alykhanjetha/ https://bsky.app/profile/ajetha.bsky.social Special Guest: Alykhan Jetha.

In this episode, Scott talks to Florian Engelhardt about concurrency in PHP. Links Florian on Mastodon – https://phpc.social/@flowcontrol Florian's Website – https://dotbox.org Article – Concurrency in PHP: What are my options? The post Community Corner: Concurrency With Florian Engelhardt appeared first on php[architect].

Concurrency (súbežnosť) je jedna z tých vecí, s ktorou sa programátor nestretne často, ale keď sa už stretne, tak by mal k tejto téme vedieť aspoň nejaké základy. The post Ep. 122 – Concurrency – Pragmatický programátor 6 appeared first on Street of Code.

Nick Lockwood of SwiftFormat (not dash) joins the show to talk about the server side Swift conference, quirks of Swift you didn't know about, language design, and the future of Swift.GuestNick Lockwood@nicklockwood (Github)Nick Lockwood (@nicklockwood@mastodon.social)Nick Lockwood | LinkedInAnnouncementsNeed help with your projects this year? BrightDigit has openings.Join Bushel BetaJoin our Brand New Patreon Page!BrightDigit #100 - Top 10 Emails Ever!

Jaim Zuber returns after over 5 years to give us an overview of looking for a job in iOS development in 2024, how has it changed, what are some things you can do now, and when becoming a manager is the right call.GuestJaim Zuber@sharpfive (GitHub)Jaim Zuber (LinkedIn)@jaimzuber@mspsocial.net (Mastodon)AnnouncementsNeed help with your projects this year? BrightDigit has openings.Join Bushel BetaJoin our Brand New Patreon Page!BrightDigit #100 - Top 10 Emails Ever!

Today on Elixir Wizards, Bryan Green shares how he transformed a vintage 1930s rotary phone into a fully functional cell phone using Elixir, Nerves, and a mix of hardware components. Bryan shares the highs and lows of his project, from decoding rotary dial clicks to troubleshooting hardware issues with LED outputs. He explains why Nerves was the perfect fit for this project, offering SSH access, over-the-air updates, and remote debugging. You'll also hear how Elixir's concurrency model helped him manage hardware inputs and outputs efficiently using GenStateMachine and Genservers. Elixir and Nerves really shine when modeling real-world systems. Bryan dives into how he used a finite state machine to track the phone's states and handled inputs from the rotary dial and hook switch via GPIO. For hardware enthusiasts, Bryan's advice is to embrace this “golden age” of DIY electronics. Whether you're experienced with embedded systems or just curious on where to start, Bryan's VintageCell can inspire you to tinker with a hardware engineering project. Key topics discussed in this episode: Advantages of functional programming and immutability in Elixir Building hardware projects using Adafruit components Why Nerves was the best choice for the VintageCell project Interpreting rotary dial clicks using GPIO and circuits.gpio Troubleshooting hardware issues with LED diagnostics Challenges in optimizing wiring and PCB design Benefits of Nerves: SSH access, OTA updates, and remote debugging Modeling real-world systems with Elixir and Nerves Implementing a finite state machine with GenStateMachine Managing input with Genservers for rotary dial and hook switch Leveraging community resources like Discord, Elixir Slack, and forums Practical advice for keeping hardware projects on track Potential applications from SMS servers to home automation Links mentioned: Vintage Cellphone: Bridging the Past and Future with Elixir (https://www.youtube.com/watch?v=U4hetzVpjmo) Seven Languages in Seven Weeks https://pragprog.com/titles/btlang/seven-languages-in-seven-weeks/ Seven More Languages https://pragprog.com/titles/7lang/seven-more-languages-in-seven-weeks/ Node.js https://github.com/nodejs https://nerves-project.org/ https://www.arduino.cc/ Adafruit Circuit Playground https://www.adafruit.com/category/965 Adafruit 3D Printed Star Trek Communicator https://learn.adafruit.com/3d-printed-star-trek-communicator Adafruit FONA 3G Cellular + GPS Breakout https://learn.adafruit.com/adafruit-fona-3g-cellular-gps-breakout/overview https://github.com/elixir-circuits/circuitsgpio Nerves SSH https://hex.pm/packages/nervesssh OTA (over-the-air) Updates with NervesHub https://www.nerves-hub.org/ https://github.com/kicad Waveshare 4G Hat for Raspberry Pi https://www.waveshare.com/sim7600e-h-4g-hat.htm https://hexdocs.pm/genstatemachine/GenStateMachine.html https://hexdocs.pm/elixir/GenServer.html https://www.sparkfun.com/ https://www.digikey.com/ USB-C Gadget Mode with Nerves https://github.com/nerves-project/nervessystemrpi4/issues/18 https://livebook.dev/ https://codestorm.me/ https://github.com/codestorm1/vintage_cell/ Special Guest: Bryan Green.

To kick off Elixir Wizards Season 13, The Creator's Lab, we're joined by Zach Daniel, the creator of Igniter and the Ash framework. Zach joins hosts Owen Bickford and Charles Suggs to discuss the mechanics and aspirations of his latest brainchild, Igniter—a code generation and project patching framework designed to revolutionize the Elixir development experience. Igniter isn't just about generating code; it's about generating smarter code. By leveraging tools like Sourcerer and Rewrite, Igniter allows developers to modify source code and batch updates by directly interacting with Elixir's AST instead of regex patching. This approach streamlines new project setup and package installations and enhances overall workflow. They also discuss the strategic implications of Igniter for the broader Elixir community. Zach hopes Igniter will foster a more interconnected and efficient ecosystem that attracts new developers to Elixir and caters to the evolving needs of seasoned Elixir engineers. Topics discussed in this episode: Advanced package installation and code generation improve the developer experience Scripting and staging techniques streamline project updates Innovative methods for smoother installation processes in Elixir packages High-level tools apply direct patches to source code Progressive feature additions simplify the mix phx.new experience Chaining installers and composing tasks for more efficient project setup Continuous improvement in developer experiences to boost Elixir adoption Encourage listeners to collaborate by sharing code generation patterns Introduction of a new mix task aimed at removing the "unless" keyword in preparation for Elixir 1.18 You can learn more in the upcoming book "Building Web Applications with Ash Framework" by Zach and Rebecca Links mentioned: https://smartlogic.io/ https://alembic.com.au/blog/igniter-rethinking-code-generation-with-project-patching https://hexdocs.pm/igniter/readme.html https://github.com/ash-project/igniter https://www.zachdaniel.dev/p/serialization-is-the-secret https://www.zachdaniel.dev/p/welcome-to-my-substack https://ash-hq.org/ https://hexdocs.pm/sourceror/readme.html https://smartlogic.io/podcast/elixir-wizards/s10-e09-hugo-lucas-future-of-elixir-community/ https://github.com/hrzndhrn/rewrite https://github.com/zachdaniel https://github.com/liveshowy/webauthn_components https://hexdocs.pm/elixir/Regex.html https://github.com/msaraiva/vscode-surface https://github.com/swoosh/swoosh https://github.com/erlef/oidcc https://alembic.com.au/ https://www.zachdaniel.dev/ Special Guest: Zach Daniel.

Tonight on GeekNights, we talk about cores and concurrency and threads and such. Also Rym and Emily fought a bear. In the news, Intel's chip instability saga has concluded, and Python 3.13.0 is pretty good.Related LinksForum ThreadMulticore Multiprocess Concurrency and SuchDiscord ChatMulticore Multiprocess Concurrency and SuchThings of the DayRym - How Mei Blows Up the GameScott - Popular Science (May 1872)

Daniel Steinberg comes in the podcast to talk about his latest book on Swift Testing as well as the state of Swift development in 2024.GuestDim Sum Thinkingdimsumthinking (@dimsumthinking@mastodon.social) - MastodonDaniel Steinberg | LinkedInAnnouncementsCome see me and Daniel at Server-Side Swift Conference. 26th-27th September 2024. London, UKuse EMPOWERAPPS to get 15% offNeed help with your projects this year? BrightDigit has openings.Join Bushel BetaJoin our Brand New Patreon Page!LinksThe Case of the Crimson Test SuiteThe Case of the Vanishing BodiesThe Curious Case of the Async CafeKeynote: A Mathematician Muses about Macros, @Models, and ML - Daniel H Steinberg - SwiftCraft 2024 - YouTubeRelated EpisodesFunctional Programming with Daniel SteinbergWWDC Notes with Cihat GündüzSOTU 2024 with Peter WithamHacking with Ignite with Paul HudsonWe Have All The Heroes with Stefano MondinoSwiftly Tooling with Pol Piella AbadiaEdge of Concurrency with Matt MassicotteSupercharged with Pedro PiñeraMicroapps Architecture with Majid JabrayilovTest-Driven Development in Swift with Gio LodiSocial MediaEmailleo@brightdigit.comGitHub - @brightdigitTwitter BrightDigit - @brightdigitLeo - @leogdionLinkedInBrightDigitLeoPatreon - brightdigitCreditsMusic from https://filmmusic.io"Blippy Trance" by Kevin MacLeod (https://incompetech.com)License: CC BY (http://creativecommons.org/licenses/by/4.0/) (00:00) - What is Swift Testing (10:04) - Benefits of Swift Testing (17:22) - Parameterized Tests (20:30) - Swift 6 (24:47) - WWDC 2024 (31:20) - Swift Data (35:10) - Swift Data

Ivan Akulov, Senior Performance Engineer at Framer, discusses optimizing React performance and major advancements in React, including hooks, concurrency, and the crucial invisible performance enhancements that make modern web applications smoother and faster. Links https://iamakulov.com https://x.com/iamakulov https://github.com/iamakulov https://www.linkedin.com/in/iamakulov https://3perf.com We want to hear from you! How did you find us? Did you see us on Twitter? In a newsletter? Or maybe we were recommended by a friend? Let us know by sending an email to our producer, Emily, at emily.kochanekketner@logrocket.com (mailto:emily.kochanekketner@logrocket.com), or tweet at us at PodRocketPod (https://twitter.com/PodRocketpod). Follow us. Get free stickers. Follow us on Apple Podcasts, fill out this form (https://podrocket.logrocket.com/get-podrocket-stickers), and we'll send you free PodRocket stickers! What does LogRocket do? LogRocket provides AI-first session replay and analytics that surfaces the UX and technical issues impacting user experiences. Start understand where your users are struggling by trying it for free at [LogRocket.com]. Try LogRocket for free today.(https://logrocket.com/signup/?pdr) Special Guest: Ivan Akulov.

In this episode, we discuss AWS Lambda provisioned concurrency. We start with a recap of Lambda cold starts and the different concurrency control options. We then explain how provisioned concurrency works to initialize execution environments in advance to avoid cold starts. We cover how to enable it, pricing details, common issues like over/under-provisioning, and alternatives like self-warming functions or using other services like ECS and Fargate.

Guest: Oleg Shanyuk, Platform Security, Delivery Hero [@deliveryherocom]On LinkedIn | https://www.linkedin.com/in/oleg-shanyuk/____________________________Hosts: Sean Martin, Co-Founder at ITSPmagazine [@ITSPmagazine] and Host of Redefining CyberSecurity Podcast [@RedefiningCyber]On ITSPmagazine | https://www.itspmagazine.com/sean-martinMarco Ciappelli, Co-Founder at ITSPmagazine [@ITSPmagazine] and Host of Redefining Society PodcastOn ITSPmagazine | https://www.itspmagazine.com/itspmagazine-podcast-radio-hosts/marco-ciappelli____________________________Episode NotesIn this On Location episode, Sean Martin discusses the complexities of application security (AppSec) and the challenges surrounding the integration of artificial intelligence (AI) with Oleg Shanyuk at the OWASP Global AppSec Global conference in Lisbon. The conversation delves into various aspects of AppSec, DevSecOps, and the broader scope of securing both web and mobile applications, as well as the cloud and container environments that underpin them.One of the core topics Martin and Shanyuk explore is the pervasive influence of AI across different sectors. AI's application in coding, for instance, can significantly expedite the development process. However, as Sean Martin highlights, AI-generated code may lack the human intuition and contextual understanding crucial for error mitigation. This necessitates deeper and more intricate code reviews by human developers, reinforcing the symbiotic relationship between human expertise and AI efficiency.Shanyuk shares insightful anecdotes about the history and evolution of programming languages and how AI's rise is reminiscent of past technological shifts. He references the advancement from physical punch cards to assembly languages and human-readable code, drawing parallels to the current AI boom. Shanyuk stresses the importance of learning from past technological evolutions to better understand and leverage AI's full potential in modern development environments.The conversation also explores the practical applications of AI in fields beyond straightforward coding. Shanyuk discusses the evolution of automotive batteries from 12 volts to 48 volts, paralleling this shift with how AI can optimize various processes in different industries. This evolution demonstrates the potential of technology to drive efficiencies and reduce costs, emphasizing the need for ongoing innovation and adaptation.Martin further navigates the discussion towards platform engineering, contrasting its benefits of consistency and control with the precision and customization needed for specific tasks. The ongoing debate encapsulates the broader dialogue within the tech community about finding the right balance between standardization and flexibility. Shanyuk's perspective offers valuable insights into how industries can leverage AI and platform engineering principles to achieve both operational efficiency and specialized functionality.The episode concludes with forward-looking reflections on the future of AI-driven models and their potential to transcend the limitations of human language and traditional coding paradigms. The thoughtful dialogue between Martin and Shanyuk leaves listeners with a deeper appreciation of the challenges and opportunities within the realm of AI and AppSec, encouraging continued exploration and discourse in these rapidly evolving fields.Be sure to follow our Coverage Journey and subscribe to our podcasts!____________________________Follow our OWASP AppSec Global Lisbon 2024 coverage: https://www.itspmagazine.com/owasp-global-2024-lisbon-application-security-event-coverage-in-portugalOn YouTube:

Guest: Oleg Shanyuk, Platform Security, Delivery Hero [@deliveryherocom]On LinkedIn | https://www.linkedin.com/in/oleg-shanyuk/____________________________Hosts: Sean Martin, Co-Founder at ITSPmagazine [@ITSPmagazine] and Host of Redefining CyberSecurity Podcast [@RedefiningCyber]On ITSPmagazine | https://www.itspmagazine.com/sean-martinMarco Ciappelli, Co-Founder at ITSPmagazine [@ITSPmagazine] and Host of Redefining Society PodcastOn ITSPmagazine | https://www.itspmagazine.com/itspmagazine-podcast-radio-hosts/marco-ciappelli____________________________Episode NotesIn this On Location episode, Sean Martin discusses the complexities of application security (AppSec) and the challenges surrounding the integration of artificial intelligence (AI) with Oleg Shanyuk at the OWASP Global AppSec Global conference in Lisbon. The conversation delves into various aspects of AppSec, DevSecOps, and the broader scope of securing both web and mobile applications, as well as the cloud and container environments that underpin them.One of the core topics Martin and Shanyuk explore is the pervasive influence of AI across different sectors. AI's application in coding, for instance, can significantly expedite the development process. However, as Sean Martin highlights, AI-generated code may lack the human intuition and contextual understanding crucial for error mitigation. This necessitates deeper and more intricate code reviews by human developers, reinforcing the symbiotic relationship between human expertise and AI efficiency.Shanyuk shares insightful anecdotes about the history and evolution of programming languages and how AI's rise is reminiscent of past technological shifts. He references the advancement from physical punch cards to assembly languages and human-readable code, drawing parallels to the current AI boom. Shanyuk stresses the importance of learning from past technological evolutions to better understand and leverage AI's full potential in modern development environments.The conversation also explores the practical applications of AI in fields beyond straightforward coding. Shanyuk discusses the evolution of automotive batteries from 12 volts to 48 volts, paralleling this shift with how AI can optimize various processes in different industries. This evolution demonstrates the potential of technology to drive efficiencies and reduce costs, emphasizing the need for ongoing innovation and adaptation.Martin further navigates the discussion towards platform engineering, contrasting its benefits of consistency and control with the precision and customization needed for specific tasks. The ongoing debate encapsulates the broader dialogue within the tech community about finding the right balance between standardization and flexibility. Shanyuk's perspective offers valuable insights into how industries can leverage AI and platform engineering principles to achieve both operational efficiency and specialized functionality.The episode concludes with forward-looking reflections on the future of AI-driven models and their potential to transcend the limitations of human language and traditional coding paradigms. The thoughtful dialogue between Martin and Shanyuk leaves listeners with a deeper appreciation of the challenges and opportunities within the realm of AI and AppSec, encouraging continued exploration and discourse in these rapidly evolving fields.Be sure to follow our Coverage Journey and subscribe to our podcasts!____________________________Follow our OWASP AppSec Global Lisbon 2024 coverage: https://www.itspmagazine.com/owasp-global-2024-lisbon-application-security-event-coverage-in-portugalOn YouTube:

Starring:k_katsumi, sonson_twit, d_date, kateinoigakukun WWDC2024の発表内容について話しました． 1. WWDC2024 2. Python vs Swift 3. 書かないと始まらない 4. 新しい計算機・・・・は・・・・ 5. すべてはIntentに集約され，アプリの個性は消える 6. Vision Pro，日本発売っ・・・・・！！ 7. Enterprise契約はなくなるらしい 8. macOSのゲーム市場・・・・・ 9. OS固有ではないソフトウェアはすべてユーザ権限で動かす方向 10. ファイルシステムを実装したことがあってもわからないFSKit 11. コンパイル時にSDKのバージョンによってコードを切り替えたい・・・ 12. 大好評のSwift Testing 13. Swift Testingの短所は？ 14. Concurrency時代のテストスイートにありかた 15. 新しいXcodeの補完はいまいち・・・・ 16. github.comのSwiftがAppleから独立 17. sonsonはPythonをやめて，Swiftを書くべきなのか 18. WWDC2024イベントやる？

The idea of smart robots automating away boring household chores sounds enticing, yet these devices rarely work as advertised: they get stuck, they break down, or are security nightmares. And so it's refreshing to see a company like Matic taking a different approach by attempting to build truly smart, reliable, and privacy-respecting robots. They use Rust for 95% of their codebase, and use camera vision to navigate, vacuum, and mop floors.I sit down with Eric Seppanen, Software Engineer at Matic, to learn about vertical integration in robotics, on-device sensor processing, large Rust codebases, and why Rust is a great language for the problem space.

In today's episode, Scott and Wes dive into the final part of our JavaScript Promises series, covering deferred promises, fetch, flow control, concurrency with libraries like p-map and p-limit, and integrating TypeScript. Show Notes 00:00 Welcome to Syntax! 00:31 Brought to you by Sentry.io. 01:11 Deferred promises. Promise.withResolvers(). Wes' TikTok. 06:10 Fetch. 09:04 Flow Control. 12:19 Concurrency, Throttling, Queuing. p-map. p-limit. 16:13 TypeScript and Promises. Hit us up on Socials! Syntax: X Instagram Tiktok LinkedIn Threads Wes: X Instagram Tiktok LinkedIn Threads Scott:X Instagram Tiktok LinkedIn Threads Randy: X Instagram YouTube Threads

This interview was recorded at GOTO Copenhagen for GOTO Unscripted.http://gotopia.techRead the full transcription of this interview hereSophie DeBenedetto - Staff Software Engineer at GitHub Andrea Leopardi - Elixir Core Team Member, Developer Advocate & Principal Engineer at VeepsRESOURCESSophiehttp://sophiedebenedetto.nychttps://twitter.com/sm_debenedettohttps://linkedin.com/in/sophiedebenedettohttps://github.com/SophieDeBenedettoAndreahttps://twitter.com/whatyouhidehttps://linkedin.com/in/anleopardihttps://andrealeopardi.comhttps://github.com/whatyouhidehttps://mas.to/@whatyouhideVideoshttps://youtu.be/mkGq1WoEvI4https://youtu.be/0ONhPnwKI1ohttps://youtu.be/-KCZvquEA6Ihttps://youtu.be/JvBT4XBdoUEhttps://youtu.be/Swj47CiK32whttps://youtu.be/PkHZPTn1brchttps://youtu.be/PEbQ-s19wKohttps://youtu.be/vS1_Z4xaeqQDESCRIPTIONSophie DeBenedetto and Andrea Leopardi in an illuminating discussion as they navigate the expansive horizons of Elixir, empowering frontend developers with Phoenix LiveView and unveiling the language's network programming prowess.This engaging conversation unveils practical applications, highlighting Elixir's elegance in crafting dynamic web solutions and addressing intricate networking challenges. Whether you're a seasoned developer or curious about Elixir's capabilities, this exploration promises a deep dive into the language's versatility.RECOMMENDED BOOKSSophie DeBenedetto & Bruce Tate • Programming Phoenix LiveViewAndrea Leopardi & Jeffrey Matthias • Testing ElixirSean Moriarity • Genetic Algorithms in ElixirSean Moriarity • Machine Learning in ElixirBruce Tate • Programmer Passport: ElixirFrancesco Cesarini & Steve Vinoski • Designing for Scalability with Erlang/OTPSaša Jurić • Elixir in ActionJoe Armstrong • Programming ErlangTwitterInstagramLinkedInFacebookLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

This episode is all about SwiftData. Steve has started using it a lot lately and talks about his experience so far trying to sync a bunch of API data into a SwiftData model as well as using a Swift Actor to control write access to the data container in a thread-safe manner. There are some really useful links in the show notes this week. You'll want to bookmark them all! ## Topics Discussed: - Introductions - Steve's Real World SwiftData Experience…so far - Maintaining a local copy of server data - https://developer.apple.com/documentation/swiftdata/maintaining-a-local-copy-of-server-data - Practical SwiftData: Building SwiftUI Applications with Modern Approaches - https://fatbobman.com/en/posts/practical-swiftdata-building-swiftui-applications-with-modern-approaches/ - Concurrency of SwiftData | Donny Wals - https://www.youtube.com/watch?v=VG4oCnQ0bfw - Observable Architecture: Structural Identity | PointFree - https://www.pointfree.co/episodes/ep260-observable-architecture-structural-identity - Populating SwiftData from Server (ETag) Explained | Azam Sharp - https://youtu.be/f_Amhej1bkM - Tangent: Rendering HTML in SwiftUI with a WebView - Wrap-Up & Jokes - https://phillycocoa.org Intro music: "When I Hit the Floor", © 2021 Lorne Behrman. Used with permission of the artist.

In this episode, I talk with Joannis Orlandos about Serverside Swift, Structured Concurrency, maintaining good, clean code, Swift Server Workgroup and meetup, and more. I recommend checking out the links below. (00:00) - Introduction (00:22) - Joannis Orlandos (00:51) - Swift Server Workgroup (04:56) - Hummingbird (20:53) - SetApp (22:07) - Structured Concurrency (27:50) - Race conditions (37:09) - Become a Patreon member (48:18) - Grab a bag of coffee for free (50:32) - Swift Server Workgroup Meetup (01:02:49) - Unbeatable software (01:03:43) - Support the podcast (01:04:36) - Rate and review As mentioned in this episodeJoannis OrlandosSwift Server WorkgroupHummingbird on GitHubStructured Concurrency with SwiftSwift Server Workgroup MeetupUnbeatable SoftwareBecome a Patreon member and help this Podcast survivehttps://www.patreon.com/compileswiftPlease leave a review and show your supporthttps://lovethepodcast.com/compileswiftYou can also show your support by buying me a coffeehttps://peterwitham.com/bmcFollow me on Mastodonhttps://iosdev.space/@Compileswift Thanks to our monthly supporters Arclite ★ Support this podcast on Patreon ★

In this episode, Simon interviews Gary Tokman, CEO at Candle, about his experience with React Native and building a personal finance app. Gary shares his background in iOS development and how he transitioned to React Native. He discusses the technology stack used in Candle, and the three main problems of React Native apps. Gary also shares his latest packages Faster Image and Blur View, along with a new library for Push notifications.Learn React Native - https://galaxies.devGary TokmanGary Twitter: https://twitter.com/f6aryCandle: https://candle.fiLinksSST: https://sst.dev/Candle on Github: https://github.com/candlefinanceSkip: https://skip.tools/TakeawaysThe React Native community faces challenges with maintaining packages, especially when it comes to finding the right package that works and is actively maintained.React Native faces three main challenges: Concurrency, Presentation, and API SupportGary works on several OS projects to bring Swift power to React Native appsFront-end development in Candle involves client-side architecture, which presents challenges in balancing performance and processing large amounts of data on the device.

In Elixir Wizards Office Hours Episode 2, "Discovery Discoveries," SmartLogic's Project Manager Alicia Brindisi and VP of Delivery Bri LaVorgna join Elixir Wizards Sundi Myint and Owen Bickford on an exploratory journey through the discovery phase of the software development lifecycle. This episode highlights how collaboration and communication transform the client-project team dynamic into a customized expedition. The goal of discovery is to reveal clear business goals, understand the end user, pinpoint key project objectives, and meticulously document the path forward in a Product Requirements Document (PRD). The discussion emphasizes the importance of fostering transparency, trust, and open communication. Through a mutual exchange of ideas, we are able to create the most tailored, efficient solutions that meet the client's current goals and their vision for the future. Key topics discussed in this episode: Mastering the art of tailored, collaborative discovery Navigating business landscapes and user experiences with empathy Sculpting project objectives and architectural blueprints Continuously capturing discoveries and refining documentation Striking the perfect balance between flexibility and structured processes Steering clear of scope creep while managing expectations Tapping into collective wisdom for ongoing discovery Building and sustaining a foundation of trust and transparency Links mentioned in this episode: https://smartlogic.io/ Follow SmartLogic on social media: https://twitter.com/smartlogic Contact Bri: bri@smartlogic.io What is a PRD? https://en.wikipedia.org/wiki/Productrequirementsdocument Special Guests: Alicia Brindisi and Bri LaVorgna.

Craig Clayton from the DesignToSwiftUI Youtube channel comes on to talk about his favorite tips as as designer when it comes to SwiftUI as well as previews his upcoming talk on testing at Deep Dish Swift.GuestCraig Clayton (YouTube @DesigntoSwiftUI)Craig Clayton (@thedevme@mastodon.cloud) - mastodon.cloudmastodon.cloud/@thedevme (@thedevme) / XCraig Clayton | LinkedInAnnouncementsNeed help with your projects this year? BrightDigit has openings.Join Bushel BetaLiveStreaming on YouTube Join me at SwiftCraftJoin our Brand New Patreon Page!Related LinksUsing ModelActor in SwiftDataRelated EpisodesTriple Glazed Apple Development with Malin Sundberg and Kai DombrowskiPixelBlitz in Public with Martin LasekLearning Judo with Sean RuckerThe Making of Callsheet with Casey LissArm Sling for Apple Watch Developers with Hidde van der PloegMy Taylor Deep Dish Swift Heroes World TourGoing Pro with Sean AllenA Swiftly Year in Review with Antoine van der LeePosture Island with Jordi BruinEmpower Station with Matt BraunIndie Dev #4 - Making an App Best-in-Class with Jordan MorganiPad Development with Adam ShawUI Design for Developers with Heidi Helen PilypasSocial MediaEmailleo@brightdigit.comGitHub - @brightdigitTwitter BrightDigit - @brightdigitLeo - @leogdionLinkedInBrightDigitLeoPatreon - brightdigitCreditsMusic from https://filmmusic.io"Blippy Trance" by Kevin MacLeod (https://incompetech.com)License: CC BY (http://creativecommons.org/licenses/by/4.0/) (00:00) - Designing with SwiftUI (11:16) - SwiftUI Tips (18:53) - What's Countdown to Binge? (25:31) - Concurrency, SwiftData, and Storyboards? (35:05) - Shapes and Fonts in SwiftUI (39:37) - Deep Slice of Design and Testing (42:45) - Vision Pro Stuff Thanks to our monthly supporters Steven Lipton ★ Support this podcast on Patreon ★

This interview was recorded at GOTO Copenhagen for GOTO Unscripted.http://gotopia.techRead the full transcription of this interview hereFrancesco Cesarini - Founder of Erlang Solutions & O'Reilly AuthorAndrea Leopardi - Elixir Core Team Member, Developer Advocate & Principal Engineer at VeepsRESOURCESFrancescohttps://twitter.com/FrancescoChttps://github.com/francescochttps://linkedin.com/in/francescocesariniAndreahttps://twitter.com/whatyouhidehttps://linkedin.com/in/anleopardihttps://andrealeopardi.comhttps://github.com/whatyouhidehttps://mas.to/@whatyouhideDESCRIPTIONUncover the fascinating journey of Erlang's transformation from a singular language to a diverse ecosystem. Francesco Cesarini, founder of Erlang Solutions, and Andrea Leopardi, a member of the Elixir Core Team, share insights into the emergence of languages on the BEAM, the impact of Elixir on the Erlang ecosystem, and the challenges and opportunities in extending the Erlang VM.The conversation explores the rich history, diverse languages, and the positive influence Elixir brings back to Erlang's ongoing developments.RECOMMENDED BOOKSAndrea Leopardi & Jeffrey Matthias • Testing ElixirFrancesco Cesarini & Steve Vinoski • Designing for Scalability with Erlang/OTPFrancesco Cesarini & Simon Thompson • Erlang ProgrammingSophie DeBenedetto & Bruce Tate • Programming Phoenix LiveViewSaša Jurić • Elixir in ActionJoe Armstrong • Programming ErlangDave Thomas • Programming Elixir ≥ 1.6: FunctionalTwitterInstagramLinkedInFacebookLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted daily!

Topics covered in this episode: 6 ways to improve the architecture of your Python project (using import-linter) Mountaineer Why Python's Integer Division Floors Hatchet Extras Joke Watch on YouTube About the show Sponsored by ScoutAPM: pythonbytes.fm/scout Connect with the hosts Michael: @mkennedy@fosstodon.org Brian: @brianokken@fosstodon.org Show: @pythonbytes@fosstodon.org Join us on YouTube at pythonbytes.fm/live to be part of the audience. Usually Tuesdays at 11am PT. Older video versions available there too. Brian #1: 6 ways to improve the architecture of your Python project (using import-linter) Piglei Using import-linter to define architectural layers check to make sure imports don't violate (import from upper layers) can also check for more contracts, such as forbidden - disallow a specific from/to import independence - list of modules that shouldn't import from each other Fixing violations a process introduced to set exceptions for each violation in a config file then fix violations 1 at a time (nice approach) use the whole team if you can Common methods for fixing dependency issues Merging and splitting modules Dependency Injection, including using protocols to keep type hints without the need to import just for types Use simpler dependency types Delaying function implementations module global methods set by caller, or adding a simple plugin/callback system Configuration driven Setting import statements in a config file and using import_string() at runtime Replace function calls with event-driven approaches Michael #2: Mountaineer Mountaineer is a batteries-included web framework for Python and React. Mountaineer focuses on developer productivity above all else, with production speed a close second.

In this episode, Christine Hall will be joined by our special guest, Kimberly Jolivette Williams. Join Christine and Kimberly as they explore the nuances of anesthesia guidelines, including the distinctions between Anesthesia and Monitored Anesthesia Care (MAC), Time Reporting, Concurrency, Modifiers, and Qualifying Circumstances. --- Support this podcast: https://podcasters.spotify.com/pod/show/coding-with-christine-hall/support

When leveraged correctly, AI can enhance human creativity and allow businesses to connect disparate systems and make informed decisions. So, what choices can manufacturing businesses take to ensure they're using AI the right way? We all know some aspects of our jobs can feel robotic, so Concurrency Chief Technology Officer, Nathan Lasnoski, suggests leaving the manual tasks to AI so you can focus on creativity. On this episode of Manufacturing Happy Hour, he shares how AI can be used to boost your team's creative abilities and explains why ROI should be your lodestar as you look to incorporate AI. Plus, he provides expert tips on how leaders can start making the right AI choices and tells us the similarities between its explosion and the Industrial Revolution. Nathan's been involved with AI for EIGHT years – so he knows what he's talking about! In this episode, find out: Nathan explains how companies can focus on “real productive AI” and transform the way they think of AI in the context of their business Why ROI should be the “guiding light” of a business' use of AI and why it is solving old problems in a brand-new way Nathan shares the story of how he and Concurrency began using AI, hiring their first data scientist around eight years ago before the AI explosion of 2022 How AI is automating intuition and connecting disparate systems to allow business leaders to make data-driven decisions with a holistic view Nathan outlines his comparisons between the AI revolution and the Industrial Revolution, exploring the positives of automating workplace processes with AI How the AI revolution has the potential to increase, not decrease, human creativity by taking manual tasks off our hands Nathan tells us the right questions executives should be asking themselves about AI, and why they need to focus on their present and future goals How the frontline workforce play a vital part in manufacturing leaders knowing which incremental and disruptive changes to make with the help of AI Enjoying the show? Please leave us a review here. Even one sentence helps. It's feedback from Manufacturing All-Stars like you that keeps us going! Tweetable Quotes: “The bar has been lowered for businesses to get into the game.” “Even medium- and small-sized organizations can translate repeatable processes into automated processes and free up their teams to be more.” “AI gives us the opportunity to unlock what is really special about each person and bring it to the forefront of our organizations.” Links & mentions: Concurrency, Devs aim for client-friendly interfaces, full support, and smooth cross-device experiences, all while ensuring scalable global accessibility Brian Evergreen on Manufacturing Happy Hour, Episode 118 Defining “Autonomous Transformation” and Avoiding “Pilot Purgatory” Jeff Winter on Manufacturing Happy Hour, Episode 149 Thriving with AI: Artificial Intelligence Strategies for Manufacturers Central...

В этом эпизоде расскажем, что же за новую модель конкурентности предлагает нам использовать Apple.Приглашённый эксперт - Василий Усов, автор книг и докладов по разработке на Swift, разработчик из VK Карты. Он разберёт Swift Concurrency от и до. Почему паралеллизм и многопоточность - разные понятия? Что такое переключение контекста, async / await и акторы?А главное - почему самое время обновлять свои знания и переходить на новую модель конкурентности

This interview was recorded at GOTO Aarhus for GOTO Unscripted.gotopia.techRead the full transcription of this interview hereRobert Virding - Erlang Co-inventor & Principal Language Expert at Erlang SolutionsFrancesco Cesarini - Founder of Erlang Solutions & O'Reilly AuthorRESOURCESRobert@rvirdinggithub.com/rvirdinglinkedin.com/in/robertvirdingFrancesco@FrancescoCgithub.com/francescoclinkedin.com/in/francescocesariniDESCRIPTIONErlang is being used in various industries demanding reliability and scalability. Its debugging tools and cross-platform compatibility has solidified its position as an invaluable choice for building resilient, concurrent, and scalable applications in a slew of use cases.Hear this GOTO Unscripted episode where Robert Virding, one of the original architects of Erlang shares the genesis of Erlang with Francesco Cesarini, founder & technical director at Erlang Solutions. Unveiling the fascinating tale behind the birth of this programming language.Virding and Cesarini delve into the initial challenges that faced the Erlang ecosystem, the remarkable journey that followed and the plans ahead. Discover how Erlang's unique design has empowered it to play a pivotal role in mission-critical applications for companies like WhatsApp, Ericsson, Klarna, and many more, demonstrating its remarkable concurrency capabilities and fault tolerance, making it an invaluable tool for building high-performance systems in today's interconnected world.RECOMMENDED BOOKSFrancesco Cesarini & Steve Vinoski • Designing for Scalability with Erlang/OTPFrancesco Cesarini & Simon Thompson • Erlang ProgrammingSaša Jurić • Elixir in ActionJoe Armstrong • Programming ErlangDave Thomas • Programming Elixir ≥ 1.6: FunctionalSimon St. Laurent • Introducing ErlangLogan, Merritt & Carlsson • Erlang and OTP in ActionMcCord, Tate & Valim • Programming Phoenix 1.4TwitterInstagramLinkedInFacebookLooking for a unique learning experience?Attend the next GOTO conference near you! Get your ticket: gotopia.techSUBSCRIBE TO OUR YOUTUBE CHANNEL - new videos posted almost daily

Learn about the intricacies of React concurrency and performance features, specifically in React 18, with Ivan Akulov, web performance engineer and consultant at PerfPerfPerf. Links https://twitter.com/iamakulov https://github.com/iamakulov https://iamakulov.com https://3perf.com https://3perf.com/talks/react-concurrency https://www.youtube.com/watch?v=8XDJ8vCtiQA Tell us what you think of PodRocket We want to hear from you! We want to know what you love and hate about the podcast. What do you want to hear more about? Who do you want to see on the show? Our producers want to know, and if you talk with us, we'll send you a $25 gift card! If you're interested, schedule a call with us (https://podrocket.logrocket.com/contact-us) or you can email producer Kate Trahan at kate@logrocket.com (mailto:kate@logrocket.com) Follow us. Get free stickers. Follow us on Apple Podcasts, fill out this form (https://podrocket.logrocket.com/get-podrocket-stickers), and we'll send you free PodRocket stickers! What does LogRocket do? LogRocket combines frontend monitoring, product analytics, and session replay to help software teams deliver the ideal product experience. Try LogRocket for free today. (https://logrocket.com/signup/?pdr) Special Guest: Ivan Akulov.

Donny Wals joins me on my podcast to talk about Do iOS. Why he's there and what he hopes to get from Do iOS.More information on his workshop and Do iOS.Learn more about Donny on his website.The Gaming BlenderHave you ever wanted to design your own video game?Listen on: Apple Podcasts SpotifyRunwayPut your mobile releases on autopilot and keep the whole team in sync throughout. More info on runway.team Lead Software Developer Learn best practices for being a great lead software developer.Practical Combine by Donny Wals Buy Donny' book on combine and support my podcast. Now that's a great deal.Practical Core Data by Donny Wals Learn Core Data from the ground up using new and modern techniques.Disclaimer: This post contains affiliate links. If you make a purchase, I may receive a commission at no extra cost to you.Support the showRate me on Apple Podcasts. Send feedback on SpeakPipeOr contact me on Mastodon: https://hachyderm.io/@appforce1Support my podcast with a monthly subscription, it really helps.My book: Being a Lead Software Developer

At the Rust Developer Retreat we explored Structured Concurrency with Tokio. With the attendees we chat about our projects and things learned, liked, and disliked about Rust. Then dive into Structured Concurrency generally and specific implementations. Discuss this episode: https://discord.gg/nPa76qF

An airhacks.fm conversation with Heinz Kabutz (@heinzkabutz) about: the click consonant, the number of parallel stream threads, the resource deadlock, the deadly embrace deadlock, the thread dump of millions threads, pinning vs mounting, Helidon Nima, jetty and quarkus are using parallel threads, virtual threads are mounted to carrier threads, the carrier thread pool, the common ForkJoinPool, concurrency vs parallelism, concurrency with structured concurrency, the size of the common thread pool can be zero, Reactive Java at Netflix, "GC Overhead Limit Exceeded", the remaining use cases for reactive programming, virtual threads for timers, the CompletableFuture Heinz Kabutz on twitter: @heinzkabutz

Matt Massicotte from Chime talks about the challenges he faced migrating the Async/Await and some misconceptions folks might have with asynchronous programming.Guest Matt Massicotte - @mattiem@mastodon.socialChime Related Links  Episode 132 - Open and Extensible with Matt Massicotte Episode 98 - Async, Await and Combine with Marin Todorov Episode 81 - Awaiting for Async with Vincent Pradeilles Episode 155 - macOS Indie Deep Cuts with Aaron Vegh Related Links  Preparing My App for Swift 6 by Cihat Gündüz Semaphore by Gwendal Roué  What's the point of Primary Associated Types? Social MediaEmailleo@brightdigit.comGitHub - @brightdigitTwitter BrightDigit - @brightdigitLeo - @leogdionLinkedInBrightDigitLeoInstagram - @brightdigitPatreon - empowerappshowCreditsMusic from https://filmmusic.io"Blippy Trance" by Kevin MacLeod (https://incompetech.com)License: CC BY (http://creativecommons.org/licenses/by/4.0/) (00:00) - What's (Not) New with ExtensionKit (03:06) - Migrating to Async/Await (10:59) - Dealing with Older APIs (12:46) - On Swift 6 (18:59) - Locks and Semaphore (24:48) - Swift Proposals (27:31) - WWDC 2023 ★ Support this podcast on Patreon ★

I saw a great question on Twitter from Frank Pachot, a developer advocate of Yugabyte. He wrote: Without thinking how your preferred database deals with it, what do you expect if: session 1 starts to reads table T session 2 drops table T session 1 continues to read The choices in his poll were: session 2 waits, session 2 fails, session 1 fails, both fail. My first thought was SQL Server and the default need for session 2 to get an exclusive lock. In that case, session 2 would wait. Most people answered that same way, but then Frank posted a follow-up with a link to his blog. The answer for Yugabyte is that session 1 fails as it gets the message that the table was deleted. Read the rest of Concurrency Challenges Around Schema Changes

It's the Season 10 finale of the Elixir Wizards podcast! José Valim, Guillaume Duboc, and Giuseppe Castagna join Wizards Owen Bickford and Dan Ivovich to dive into the prospect of types in the Elixir programming language! They break down their research on set-theoretical typing and highlight their goal of creating a type system that supports as many Elixir idioms as possible while balancing simplicity and pragmatism. José, Guillaume, and Giuseppe talk about what initially sparked this project, the challenges in bringing types to Elixir, and the benefits that the Elixir community can expect from this exciting work. Guillaume's formalization and Giuseppe's "cutting-edge research" balance José's pragmatism and "Guardian of Orthodoxy" role. Decades of theory meet the needs of a living language, with open challenges like multi-process typing ahead. They come together with a shared joy of problem-solving that will accelerate Elixir's continued growth. Key Topics Discussed in this Episode: Adding type safety to Elixir through set theoretical typing How the team chose a type system that supports as many Elixir idioms as possible Balancing simplicity and pragmatism in type system design Addressing challenges like typing maps, pattern matching, and guards The tradeoffs between Dialyzer and making types part of the core language Advantages of typing for catching bugs, documentation, and tooling The differences between typing in the Gleam programming language vs. Elixir The possibility of type inference in a set-theoretic type system The history and development of set-theoretic types over 20 years Gradual typing techniques for integrating typed and untyped code How José and Giuseppe initially connected through research papers Using types as a form of "mechanized documentation" The risks and tradeoffs of choosing syntax Cheers to another decade of Elixir! A big thanks to this season's guests and all the listeners! Links and Resources Mentioned in this Episode: Bringing Types to Elixir | Guillaume Duboc & Giuseppe Castagna | ElixirConf EU 2023 (https://youtu.be/gJJH7a2J9O8) Keynote: Celebrating the 10 Years of Elixir | José Valim | ElixirConf EU 2022 (https://youtu.be/Jf5Hsa1KOc8) OCaml industrial-strength functional programming https://ocaml.org/ ℂDuce: a language for transformation of XML documents http://www.cduce.org/ Ballerina coding language https://ballerina.io/ Luau coding language https://luau-lang.org/ Gleam type language https://gleam.run/ "The Design Principles of the Elixir Type System" (https://www.irif.fr/_media/users/gduboc/elixir-types.pdf) by G. Castagna, G. Duboc, and J. Valim "A Gradual Type System for Elixir" (https://dlnext.acm.org/doi/abs/10.1145/3427081.3427084) by M. Cassola, A. Talagorria, A. Pardo, and M. Viera "Programming with union, intersection, and negation types" (https://www.irif.fr/~gc/papers/set-theoretic-types-2022.pdf), by Giuseppe Castagna "Covariance and Contravariance: a fresh look at an old issue (a primer in advanced type systems for learning functional programmers)" (https://www.irif.fr/~gc/papers/covcon-again.pdf) by Giuseppe Castagna "A reckless introduction to Hindley-Milner type inference" (https://www.lesswrong.com/posts/vTS8K4NBSi9iyCrPo/a-reckless-introduction-to-hindley-milner-type-inference) Special Guests: Giuseppe Castagna, Guillaume Duboc, and José Valim.

Today on Elixir Wizards, José Valim, creator of the Elixir programming language, joins hosts Sundi Myint and Owen Bickford to discuss the future of Elixir, upcoming features, changes to the language and ecosystem, and the potential for a type system. José discusses how Elixir's extensibility allows the ecosystem to grow with new tools and libraries, all while requiring few languages to the core language. Key Takeaways: The origin of the famous rainbow heart combo José's hands-off approach to planning the ecosystem which allows community contribution without reliance on the core team The success and growth of the Elixir community Lessons learned in the first ten years of the language The evolution of Elixir's documentation and the role of Livebook in creating more interactive and engaging learning experiences The potential for Elixir Nx to make numerical computation, machine learning, and data science more accessible to Elixir developers Potential implementation of a gradual type system and the importance of backwards compatibility The role of the Elixir community in shaping the language's development and ecosystem, including the importance of open-source contributions Whether we'll see Elixir 2.0 in the next decade Links mentioned in this episode: Josė Valim Keynote ElixirConf EU Bringing Elixir to Life (https://www.youtube.com/watch?v=xItzdrzY1Dc) Dashbit - https://dashbit.co/ Elixir programming language: https://elixir-lang.org/ ElixirConf: https://elixirconf.com/ ElixirForum: https://elixirforum.com/ Elixir's Logger library: https://hexdocs.pm/logger/Logger.html José's Twitter: https://twitter.com/josevalim ElixirLS (Elixir Language Server) https://github.com/elixir-lsp/elixir-ls Mermaid Charts in Livebook - https://news.livebook.dev/date/2022/1 IEx - https://hexdocs.pm/iex/1.14/IEx.html Numerical Elixir - Nx: https://hexdocs.pm/nx/getting-started.html Nerves: https://hexdocs.pm/nerves/getting-started.html Membrane: https://hexdocs.pm/membrane/getting-started.html Dialyxir: https://hexdocs.pm/dialyxir/readme.html LiveBook: https://hexdocs.pm/livebook/getting-started.html Bumblebee: https://github.com/elixir-nx/bumblebee Special Guest: José Valim.

Today on Elixir Wizards, Sundi Myint and Owen Bickford are joined by Saša Jurić, distinguished developer, mentor, and author of Elixir in Action. They discuss the future of training and education in Elixir, challenges faced by new Elixir developers, Phoenix generators, peer mentorship, the emergence of types, and when it's time to close the umbrella. Key Takeaways: The functional programming paradigm, the actor model, and concurrency Adapting to the Elixir syntax and tooling The role of community, mentorship, and continuous learning in Elixir education The pros and cons of Phoenix generators for Elixir development Customizing templates in the Phoenix priv directory to better suit individual needs The importance of understanding and adapting generated code for maintainability and proper abstractions Importance of having a clear separation between core and interface Adapting to different opinions and preferences within a development team Refactoring and restructuring code to improve quality and reduce complexity Static typing for better documentation and the limitations of dynamic code Umbrella apps vs. mix configuration and how to avoid complexity Links Mentioned in this Episode: Enter to win a copy of Elixir in Action: https://smr.tl/2023bookgiveaway Elixir in Action by Saša Jurić https://www.manning.com/books/elixir-in-action 35% discount code for book on manning.com: podexwizards20 Saša's Website/Blog TheErlangelist.com (https://www.theerlangelist.com/) Towards Maintainable Elixir - Saša Jurić's Medium Blog Article Series (https://medium.com/very-big-things/towards-maintainable-elixir-the-core-and-the-interface-c267f0da43) Boundary (https://hex.pm/packages/boundary): Managing cross-module dependencies in Elixir projects Site Encrypt (https://hex.pm/packages/site_encrypt): Integrated Certification via Let's Encrypt for Elixir-powered sites Authentication Generator in Phoenix: https://hexdocs.pm/phoenix/mixphxgen_auth.html Ecto query generator for Elixir https://hexdocs.pm/ecto/Ecto.html GraphQL: Query language for APIs https://graphql.org/ Dialyxir: https://hexdocs.pm/dialyxir/readme.html Nx (Numerical Elixir) GitHub Repository: https://github.com/elixir-nx/nx ElixirLS (Elixir Language Server) GitHub Repository: https://github.com/elixir-lsp/elixir-ls Special Guest: Saša Jurić.

Elixir Wizards Owen Bickford and Dan Ivovich are joined by Mike Waud, Senior Software Engineer at SparkMeter, and Tony Winn, Lead Software Architect at Generac, to discuss the future of the BEAM in the electric grid, how their companies use Elixir, and the challenges they face in implementing cutting-edge technologies in an environment with a mix of old and new systems. Both guests have backgrounds in various programming languages before turning to Elixir for its functional programming capabilities, concurrency, and reliability. Elixir's portability allows it to be used in various environments, from cloud-based systems to more conservative organizations that prefer running software off the cloud. Key topics discussed in this episode: • Technology sophistication varies across different regions and industries • BEAM's reliability, concurrency, and scaling in electric grid systems • Using Elixir for caching, telemetry, and managing traffic spikes • Elixir fits well for devices due to its fault tolerance and supervision trees • Observability with telemetry hooks for understanding system performance • Traffic patterns in the grid space are often dictated by weather and human activity, requiring efficient handling • The balance between using Elixir/BEAM and other tools depending on use case • Using Elixir tools like Broadway to work with event queues and Nebulex for distributed caching • The future of the electric grid and its evolution over the next 10 years, including a shift towards more distributed energy generation • Global lessons about grid management, solar penetration, regulations, and energy storage • Prioritizing data in IoT systems and processing data at the edge of the network • Gratitude for open-source contributors in the Elixir community Links in this episode: SparkMeter: https://www.sparkmeter.io/ Generac: https://www.generac.com/ SmartLogic - https://smartlogic.io/jobs Gary Bernhardt's talk on functional core and imperative shell: https://www.destroyallsoftware.com/talks/boundaries Joe Armstrong's Erlang book: https://pragprog.com/titles/jaerlang/programming-erlang/ The Nerves podcast and documentation: https://nerves-project.org/ Special Guests: Mike Waud and Tony Winn.

[00:01:52] There's a Remote Uber Eats Food Review going on here.[00:07:20] Andrew explains the new Stimulus Outlets API and what it does.[00:12:58] Jason talks about this week and dealing with isolated things that are decoupled and battling race conditions with events firing. Chris mentions it has concurrency problems and makes things much harder.   [00:16:14] Speaking of webhooks, Jason shifts gears and tells us about a Tweet from Wes Bos that ruined his morning. Also, he explains that he's only been doing connected webhooks on Job Boardly, what he did with stripe event, and wonders if Chris encountered what he did with stripe event.[00:20:04] When Jason looked into Stripe event, he noticed you can give multiple signing secrets since there's a separate secret for each connect and regular and we find out how it's used.[00:22:30] In case you didn't know, Stripe event isn't a Stripe package, it's a third-party gem for processing stripe webhooks and the guys explain how it works. Also, Chris talks about the friendly id history feature and Jason tells us about using routing constraints. [00:26:05] Chris feels like not enough people use the routing constraints and Jason details what routing constraints does and how he uses it with a board constraint.[00:31:48] What's the downside to current attributes and we've got concurrency problems, bro! [00:34:55] Chris gives a shoutout to Carlos Antonio who's working on fixing up Responders and Devise, which is so needed. Also, he shares one of the Jumpstart customers talking about integrating with an API that doesn't have a Ruby gem, and Chris tells us he had a trick up his sleeve and what he did. [00:43:17] Andrew shares a pro tip of creating class methods, and we hear about a new little gem Chris started working on called, ReviseAuth, and he's looking for contributors.Panelists:Jason CharnesChris OliverAndrew MasonSponsor:HoneybadgerLinks:Jason Charnes TwitterChris Oliver TwitterAndrew Mason TwitterViral review of Olive Garden makes 85 year old grandma internet star (yahoo! news)Stimulus Outlets Stripe_event 2.7.0Wes Bos TweetFriendly_id 5.5.0Carlos Antonio TwitterRails adds ‘authenticate_by' method when using ‘has_secure_password'ReviseAuthRuby Radar TwitterRuby for All Podcast

Ben Scheirman returns to the show to discuss how Swift's built-in concurrency features, such as async/await and tasks, can be used in practice when building apps for Apple's platforms.

Neck StuffAlpine Components and Tailwind UIGo Routines and Channels

You all learn about new Magic sets one at a time, but that's not how they're made. This podcast will illustrate what it's like to make many products all at once.