Podcasts about dependency management

Highlights from this week's conversation include:Mark's Background and Journey in Data (1:08)Mark's Time at Microsoft (5:33)Internal Adoption of Azure (9:20)Understanding Pain Points (11:06)Complexity in Software Development (13:15)Microservices Architecture Overview (17:15)Microservices vs. Monolith (22:08)Modernizing Legacy Applications (24:39)Dependency Management with Dapr (29:43)Infrastructure as Code (33:04)AI's Rapid Evolution and Vendor Changes (37:27)Language Models in Application Development (39:05)AI in Creative Applications (42:59)The Future of Backend Development (47:22)Streamlining Development Processes (49:29)Dapr as an Open Source Solution (51:11)Getting Started with Dapr and Parting Thoughts (51:39)The Data Stack Show is a weekly podcast powered by RudderStack, the CDP for developers. Each week we'll talk to data engineers, analysts, and data scientists about their experience around building and maintaining data infrastructure, delivering data and data products, and driving better outcomes across their businesses with data.RudderStack helps businesses make the most out of their customer data while ensuring data privacy and security. To learn more about RudderStack visit rudderstack.com.

Play audio-only episode | Play video episode Click above to play either the audio-only episode or video episode in a new window. Episode Summary (See the "Resources" section below to download the handout with the "Three Top Dependency Management Mistakes and How to Avoid Them".) Dependency management is a crucial yet often overlooked aspect of project success. In this episode, Bryan Barrow, author of Dependency Management, shares his expertise on how project managers can effectively navigate and manage dependencies to ensure timely and efficient project delivery. With decades of experience in helping organizations tackle complex projects, Bryan emphasizes the importance of communication, collaboration, and proactive planning.

Play audio-only episode | Play video episode Click above to play either the audio-only episode or video episode in a new window. Episode Summary (See the "Resources" section below to download the handout with the "Three Top Dependency Management Mistakes and How to Avoid Them".) Dependency management is a crucial yet often overlooked aspect of project success. In this episode, Bryan Barrow, author of Dependency Management, shares his expertise on how project managers can effectively navigate and manage dependencies to ensure timely and efficient project delivery. With decades of experience in helping organizations tackle complex projects, Bryan emphasizes the importance of communication, collaboration, and proactive planning.

Send us a textIn this episode of Definitely Maybe Agile, Peter Maddison and David Sharrock explore the evolution of quarterly planning from traditional PI planning events to more streamlined modern approaches. They discuss how effective quarterly planning reveals organizational dependencies, aligns priorities across teams, and helps maintain focus on delivering value. The hosts share insights on avoiding common pitfalls like over-planning future work and emphasize the importance of maintaining flexibility while ensuring clear direction for immediate execution.This week´s takeaways:Clear, sequenced priorities shared across teams - focus on completing initiatives before starting new onesDetailed planning for immediate work (1-2 months), with less detail for future monthsActive dependency management to identify and address bottlenecks early

Carmen Huidobro shares her journey and insights on effectively managing dependencies in React project, discussing the challenges and strategies for keeping a codebase up-to-date, including auditing and upgrading dependencies. She also talks tools and techniques that can simplify the process! Links https://linkedin.com/in/carmen-huidobro https://carmenh.dev https://x.com/holasoymilk Untangling Your Dependencies: Pattern for well-knitted JavaScript Project (https://www.youtube.com/watch?v=hpnbOrYPm58) https://www.amazon.com/stores/Michael-C.-Feathers/author/B001IGFN0W 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: Carmen Huidobro.

Malicious NPM packages are sneaking into codebases while FFmpeg devs prove old-school assembly skills can still smoke the competition. Plus, a rare bee species takes on Zuck's AI dreams.

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.

In this episode: Juno for visionOS removed from the App Store—what does it mean for developers? Also: Patreon news and update, as well as Swift Remote Studio Coworking BETA!

Absolute AppSec welcomes Darren Meyer (@DarrenPMeyer on infosec.exchange and X platform) from Endor Labs as a guest on the show to discuss Endor Lab's newly released 2024 Dependency Management Report. Implementation of reachability analysis as a sine qua non of effective dependency management is one of the top-line takeaways from the newly released report. The discussion dives deeper with Darren during the livestream to talk about useful lessons from the report's findings.

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 Office Hours Episode 6, SmartLogic Developers Anna Dorigo and Bilal Hankins join Elixir Wizards Sundi and Dan to discuss their experiences maintaining a decade-old Ruby on Rails codebase. They delve into the critical importance of deeply understanding the codebase, keeping dependencies current, and adapting to the original application's evolving priorities and design choices. The conversation spans a range of topics, including accessibility, testing, monitoring, and the challenges of deploying database migrations in production environments. The guests share effective strategies for sustaining and enhancing older codebases, such as employing automated tools, performing code audits, and adhering to clean coding principles. Key topics discussed in this episode: Grasping the legacy codebase and its historical context Overcoming accessibility issues in older applications Safe dependency management and upgrades The effects of application scaling on database performance The critical role of comprehensive test suites in legacy systems Using tools like Sentry for error tracking and performance monitoring The benefits of automated security and dependency scans Juggling client needs with budget constraints Local simulation techniques for large datasets The value of iterative code reviews and maintaining clean code Utilizing git history for contextual understanding Onboarding strategies for legacy projects Removing obsolete code and avoiding "magic numbers" Importance of descriptive naming for better code clarity Leveraging a rich repository of example code for learning and reference Proactive code audits to anticipate issues Managing pull request sizes for smoother reviews Communicating effectively about upgrades and potential impacts Strategies for handling large databases efficiently Ensuring thorough test coverage Keeping open lines of communication with clients regarding ongoing maintenance Links mentioned: COBOL programming language https://developer.ibm.com/languages/cobol/ Ruby on Rails https://rubyonrails.org/ ARIA Rules (Accessible Rich Internet Applications) https://www.w3.org/TR/using-aria/ Shawn Vo on Elixir as a Competitive Advantage https://smartlogic.io/podcast/elixir-wizards/s5e5-vo/ Bundler Audit Ruby Gem https://rubygems.org/gems/bundler-audit/ Sentry application monitoring and error tracking software  https://sentry.io/ Dependabot Github automated dependency updates Mix hex.audit https://hexdocs.pm/hex/Mx.Tasks.Hex.Audit.html Git Blame https://git-scm.com/docs/git-blame Cow hoof trimming videos - The Hoof GP on YouTube (TW graphic imagery) Special Guests: Anna Dorigo and Bilal Hankins.

For the final episode of Elixir Wizards' Season 11 “Branching Out from Elixir,” we're featuring a recent discussion from the Software Unscripted podcast. In this conversation, José Valim, creator of Elixir, interviews Richard Feldman, creator of Roc. They compare notes on the process and considerations for creating a language. This episode covers the origins of creating a language, its influences, and how goals shape the tradeoffs in programming language design. José and Richard share anecdotes from their experiences guiding the evolution of Elixir and Roc. The discussion provides an insightful look at the experimentation and learning involved in crafting new languages. Topics discussed in this episode What inspires the creation of a new programming language Goals and use cases for a programming language Influences from Elm, Rust, Haskell, Go, OCaml, and more Tradeoffs involved in expressiveness of type systems Opportunistic mutation for performance gains in a functional language Minimum version selection for dependency resolution Build time considerations with type checking and monomorphization Design experiments and rolling back features that don't work out History from the first simple interpreter to today's real programming language Design considerations around package management and versioning Participation in Advent of Code to gain new users and feedback Providing performance optimization tools to users in the future Tradeoffs involved in picking integer types and arithmetic Comparing floats and equality checks on dictionaries Using abilities to customize equality for custom types Ensuring availability of multiple package versions for incremental upgrades Treating major version bumps as separate artifacts Roc's focus on single-threaded performance Links mentioned in this episode Software Unscripted Podcast https://feeds.resonaterecordings.com/software-unscripted Roc Programming Language https://www.roc-lang.org/ Roc Lang on Github https://github.com/roc-lang/roc Elm Programming Language https://elm-lang.org/ Elm in Action by Richard Feldman https://www.manning.com/books/elm-in-action Richard Feldman on Github https://github.com/rtfeldman Lua Programming Language https://www.lua.org/ Vimscript Guide https://google.github.io/styleguide/vimscriptfull.xml OCaml Programming Language https://ocaml.org/ Advent of Code https://adventofcode.com/ Roc Language on Twitter https://twitter.com/roclang Richard Feldman on Twitter https://twitter.com/rtfeldman Roc Zulip Chat https://roc.zulipchat.com Clojure Programming Language https://clojure.org/ Talk: Persistent Data Structures and Managed References by Rich Hickey https://www.youtube.com/watch?v=toD45DtVCFM Koka Programming Language https://koka-lang.github.io/koka/doc/index.html Flix Programming Language https://flix.dev/ Clojure Transients https://clojure.org/reference/transients Haskell Software Transactional Memory https://wiki.haskell.org/Softwaretransactional_memory Rust Traits https://doc.rust-lang.org/book/ch10-02-traits.html CoffeeScript https://coffeescript.org/ Cargo Package Management https://doc.rust-lang.org/book/ch01-03-hello-cargo.html Versioning in Golang https://research.swtch.com/vgo-principles Special Guests: José Valim and Richard Feldman.

It's 2024, and Dave and Sven are back to talk plans for the Swift Package Index development over the coming year. They also talk about a light-hearted but also accidentally disastrous recent event in the npm package ecosystem, plans around how the Swift Package Index will approach Swift 6 support, and of course more package recommendations!  NewsWhen "Everything" Becomes Too Much by Feross AboukhadijehPackagesswift-gopher by Navan ChauhanThe Web Before the WebWikipedia: Gopher (protocol)package-benchmark by Joakim HassilaOn percentiles: Wikipedia: Seven-number summaryGil Tene: Dispelling standard deviationPlusNightMode by Daniel Lyonswebsocket-actor-system by Stuart A. Malone

Today on Elixir Wizards, Wojtek Mach of HexPM and Amal Hussein, engineering leader and former NPM team member, join Owen Bickford to compare notes on package management in Elixir vs. JavaScript. This lively conversation covers everything from best practices for dependency management to API design, SemVer (semantic versioning), and the dark ages of web development before package managers existed. The guests debate philosophical differences between the JavaScript and Elixir communities. They highlight the JavaScript ecosystem's maturity and identify potential areas of improvement, contrasted against Elixir's emphasis on minimal dependencies. Both guests encourage engineers to publish packages, even small ones, as a learning opportunity. Topics discussed in this episode: Leveraging community packages rather than reinventing the wheel Vetting packages carefully before adopting them as dependencies Evaluating security, performance, and bundle size when assessing packages Managing transitive dependencies pulled in by packages Why semantic versioning is difficult to consistently enforce Designing APIs with extensibility and backward compatibility in mind Using tools like deprecations to avoid breaking changes in new releases JavaScript's preference for code reuse over minimization The Elixir community's minimal dependencies and avoidance of tech debt Challenges in early package management, such as global dependency Learning from tools like Ruby Gems and Bundler to improve experience How log files provide visibility into dependency management actions How lock files pin dependency versions for consistency Publishing packages democratizes access and provides learning opportunities Linting to enforce standards and prevent certain bugs Primitive-focused packages provide flexibility over highly opinionated ones Suggestions for improving documentation and guides Benefits of collaboration between programming language communities Links mentioned in this episode: Node.js https://github.com/nodejs npm JavaScript Package Manager  https://github.com/npm JS Party Podcast https://changelog.com/jsparty Dashbit https://dashbit.co/ HexPM Package Manager for Erlang https://hex.pm/ HTTP Client for Elixir https://github.com/wojtekmach/req Ecto Database-Wrapper for Elixir https://github.com/elixir-ecto (Not an ORM) XState Actor-Based State Management for JavaScript https://xstate.js.org/docs/ Supply Chain Protection for JavaScript, Python, and Go  https://socket.dev/ MixAudit https://github.com/mirego/mixaudit NimbleTOTP Library for 2FA https://hexdocs.pm/nimbletotp/NimbleTOTP.html Microsoft Azure https://github.com/Azure Patch Package https://www.npmjs.com/package/patch-package Ruby Bundler to manage Gem dependencies https://github.com/rubygems/bundler npm-shrinkwrap https://docs.npmjs.com/cli/v10/commands/npm-shrinkwrap SemVer Semantic Versioner for NPM https://www.npmjs.com/package/semver Spec-ulation Keynote - Rich Hickey https://www.youtube.com/watch?v=oyLBGkS5ICk Amal's favorite Linter https://eslint.org/ Elixir Mint Functional HTTP Client for Elixir https://github.com/elixir-mint Tailwind Open Source CSS Framework https://tailwindcss.com/ WebauthnComponents https://hex.pm/packages/webauthn_components Special Guests: Amal Hussein and Wojtek Mach.

On today's episode, Elixir Wizards Owen Bickford and Dan Ivovich compare notes on building web applications with Elixir and the Phoenix Framework versus Ruby on Rails. They discuss the history of both frameworks, key differences in architecture and approach, and deciding which programming language to use when starting a project. Both Phoenix and Rails are robust frameworks that enable developers to build high-quality web apps—Phoenix leverages functional programming in Elixir and Erlang's networking for real-time communication. Rails follows object-oriented principles and has a vast ecosystem of plug-ins. For data-heavy CRUD apps, Phoenix's immutable data pipelines provide some advantages. Developers can build great web apps with either Phoenix or Rails. Phoenix may have a slight edge for new projects based on its functional approach, built-in real-time features like LiveView, and ability to scale efficiently. But, choosing the right tech stack depends heavily on the app's specific requirements and the team's existing skills. Topics discussed in this episode: History and evolution of Phoenix Framework and Ruby on Rails Default project structure and code organization preferences in each framework Comparing object-oriented vs functional programming paradigms CRUD app development and interaction with databases Live reloading capabilities in Phoenix LiveView vs Rails Turbolinks Leveraging WebSockets for real-time UI updates Testing frameworks like RSpec, Cucumber, Wallaby, and Capybara Dependency management and size of standard libraries Scalability and distribution across nodes Readability and approachability of object-oriented code Immutability and data pipelines in functional programming Types, specs, and static analysis with Dialyzer Monkey patching in Ruby vs extensible core language in Elixir Factors to consider when choosing between frameworks Experience training new developers on Phoenix and Rails Community influences on coding styles Real-world project examples and refactoring approaches Deployment and dev ops differences Popularity and adoption curves of both frameworks Ongoing research into improving Phoenix and Rails Links Mentioned in this Episode: SmartLogic.io (https://smartlogic.io/) Dan's LinkedIn (https://www.linkedin.com/in/divovich/) Owen's LinkedIn (https://www.linkedin.com/in/owen-bickford-8b6b1523a/) Ruby https://www.ruby-lang.org/en/ Rails https://rubyonrails.org/ Sams Teach Yourself Ruby in 21 Days (https://www.overdrive.com/media/56304/sams-teach-yourself-ruby-in-21-days) Learn Ruby in 7 Days (https://www.thriftbooks.com/w/learn-ruby-in-7-days---color-print---ruby-tutorial-for-guaranteed-quick-learning-ruby-guide-with-many-practical-examples-this-ruby-programming-book--to-build-real-life-software-projects/18539364/#edition=19727339&idiq=25678249) Build Your Own Ruby on Rails Web Applications (https://www.thriftbooks.com/w/build-your-own-ruby-on-rails-web-applications_patrick-lenz/725256/item/2315989/?utm_source=google&utm_medium=cpc&utm_campaign=low_vol_backlist_standard_shopping_customer_acquisition&utm_adgroup=&utm_term=&utm_content=593118743925&gad_source=1&gclid=CjwKCAiA1MCrBhAoEiwAC2d64aQyFawuU3znN0VFgGyjR0I-0vrXlseIvht0QPOqx4DjKjdpgjCMZhoC6PcQAvD_BwE#idiq=2315989&edition=3380836) Django https://github.com/django Sidekiq https://github.com/sidekiq Kafka https://kafka.apache.org/ Phoenix Framework https://www.phoenixframework.org/ Phoenix LiveView https://hexdocs.pm/phoenixliveview/Phoenix.LiveView.html#content Flask https://flask.palletsprojects.com/en/3.0.x/ WebSockets API https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API WebSocket connection for Phoenix https://github.com/phoenixframework/websock Morph Dom https://github.com/patrick-steele-idem/morphdom Turbolinks https://github.com/turbolinks Ecto https://github.com/elixir-ecto Capybara Testing Framework https://teamcapybara.github.io/capybara/ Wallaby Testing Framework https://wallabyjs.com/ Cucumber Testing Framework https://cucumber.io/ RSpec https://rspec.info/

#Nisha, Dan, and Prateek talk about all the problems with dependency management. How focusing on dependency elimination instead, can produce better results. All that, with a good dose of rambling thrown in.

In dieser Folge sprechen Marc Ollmann, Product Manager bei HubSpot und Emil Kabisch, Product Lead & Product Coach, über Product Management in Start-ups bis hin zu größeren Unternehmen und wie und warum Freelancing Product Management funktioniert.   Themen: [03:25] Remote Work Hacks und Virtueller Office Space  [12:46] Der Weg zum Product Manager  [14:50] Product Management in Startups  [24:07] Spezialisierte PMs [30:35] Kommunikation   [34:28] Dependency Management [47:04] Freelance PMs VS. Klassische PMs  [49:20] Die 3 Learnings Feedback zu unserem Digital Business Podcast: Gerne an podcast-dach@hubspot.com. Erfahre mehr über unseren Podcast rund um Marketing, Vertrieb, Kundenservice und CRM  unter: https://www.hubspot.de/podcasts/the-digital-helpdesk 

This was a webinar I did on June 01 2023 but never got around editing it. The topic is Dependency Management and how it impacts organizational culture where I share my personal experience working dependencies on team, program and enterprise level.

Dependency management - évadzáró by Letscode.hu

Remember: you can also always follow the show on Twitter @dotnetcoreshow, and the shows host on Twitter @podcasterJay or visit our Contact page. Welcome to season 5 of the award-winning .NET Core Podcast! Check that link for proof. Hello everyone and welcome to THE .NET Core Podcast. An award-winning podcast where we reach into the core of the .NET technology stack and, with the help of the .NET community, present you with the information that you need in order to grok the many moving parts of one of the biggest cross-platform, multi-application frameworks on the planet. Software maintenance is an integral part of any software development project, but it can often be neglected, leading to a range of problems down the line. M. Scott Ford, the co-founder, chief code whisperer, and CTO of CorgyBytes, is passionate about helping teams make improvements to their existing software systems rather than throwing them away and starting from scratch. In this episode of The .NET Core Podcast, Ford and Jamie discussed the challenges of maintaining software and some of the tools they use to make it easier. One of the tools they discussed was Freshli, a tool that visualizes tech debt and shows how difficult a codebase is to work with. It tracks the age of dependencies and can help identify potential risks before they become major problems. They also discussed the Equifax hack from 2017, which was caused by a single outdated dependency. This highlights the importance of keeping dependencies up to date and the potential risks of neglecting them. The conversation also touched on the need for more spaces for developers to meet up and exchange ideas and feedback. Ford and Taylor believe that the real nuggets of information are shared in the conversations that happen between talks or at the pub afterwards, and that these sessions allow people to do that organically. One key takeaway from the discussion was the idea of making small, incremental improvements to a project rather than trying to fix everything at once. This approach is similar to a sports team focusing on individual attributes to improve overall performance. It can be more manageable and less overwhelming for a team to make small changes rather than trying to tackle everything at once. The podcast also highlighted the challenge of dependencies becoming out of date and the importance of tracking and updating them regularly to reduce risk. Ford and Taylor discussed the use of dependency freshness metrics, specifically the libyear metric, to track the age of dependencies and how it changes over time. This metric can be used to communicate the level of risk a development team is carrying to leadership. Overall, the conversation in this episode sheds light on the importance of software maintenance and the tools available to make it easier. Outdated dependencies in software projects can have a significant impact on productivity and security, but it is often an invisible problem that goes unnoticed by leadership. By implementing tools like Freshli and tracking the age of dependencies, teams can reduce the potential risks and make software maintenance more manageable. The full show notes, including links to some of the things we discussed and a full transcription of this episode, can be found at https://dotnetcore.show/episode-124-breaking-up-with-tech-debt-a-love-story-with-m-scott-ford/ Useful Links from the episode: The .NET Core Podcast Discord Server Part one of my discussion with M. Scott Ford CorgyBytes Legacy Code Rocks Legacy Code Rocks on Mastadon MenderCon libyear Measuring Dependency Freshness in Software Systems FrequencyReducesDifficulty by Martin Fowler Freshli https://freshli.app/ https://freshli.io/ https://github.com/corgibytes Software bill materials Ruby Gems PyPy https://owasp.org/www-project-cyclonedx/ Remember to rate and review the show on Apple Podcasts, Podchaser, or wherever you find your podcasts, this will help the show's audience grow. Or you can just share the show with a friend. And don't forget to reach out via our Contact page. We're very interested in your opinion of the show, so please get in touch. You can support the show by making a monthly donation on the show's Patreon page at: https://www.patreon.com/TheDotNetCorePodcast

We share how to manage project dependencies in a way that brings results. We are going to define what a dependency is and how to manage your dependencies to ensure that projects you are a part of are delivered on time and with quality. In the end we will provide a checklist that our listeners can use to ensure that their dependencies are always satisfied.

Baruch Sadogursky (Chief Sticker Officer at JFrog) joins Natalie & Johnny to lament the current state of dependency management in Go and other languages. They discuss the problems dependency managers face, possible technical mitigations like SBOMs, people problems that will never be solved by tech, and take questions from listeners in the #gotimefm channel of Gophers Slack.

Baruch Sadogursky (Chief Sticker Officer at JFrog) joins Natalie & Johnny to lament the current state of dependency management in Go and other languages. They discuss the problems dependency managers face, possible technical mitigations like SBOMs, people problems that will never be solved by tech, and take questions from listeners in the #gotimefm channel of Gophers Slack.

Steve Wells is a former developer, Scrum master, and agile coach who now builds online games and simulations related to Agile software development practices.ResourcesAgile Cambridge 2018 talk: Efficiencies in interdependent agile teamsNo Estimates Board Game by Matt PhilipBook: The Goal by Eliyahu M. GoldrattBook: The Phoenix Project by Gene KimThe Pareto PrincipleThe Phoenix Project DevOps SimulationGuestSteve WellsContact via web site: https://agilesimulations.co.uk/LinkedIn: https://www.linkedin.com/in/hogsmill/Watch this episode on YouTube.

Ola Ellnestam, along with co-author Daniel Brolund, wrote the book The Mikado Method, which describes an incremental approach to code refactoring, as well as project management.  In this interview Ola discusses the application of the technique, common pitfalls and objections to it, and provides insight into how the technique can be used to help communicate technical debt and dependencies with non-technical stakeholders. ResourcesBook: The Mikado Method by Ola ellnestam and Daniel BrolundBlog post: test && commit || revert by Kent BeckVideo: The Mikado Method: Increase Productivity, Workflow Management, and Sex Appeal! by Jonathan HallThe Mikado ToolGuestOla EllnestamTwitter: @ellnestamLinkedIn: ellnestamEmail: ola@agical.seWatch this episode on YouTube.

How did you approach versioning and dependency management when you were building this reusable component library at PayPal? I would like to know 1. How did you go about introducing breaking changes? 2. How did you make sure that people are using the latest version of your library or it doesn't matter if they are using the same version? What's bad about having different teams using different versions of the same library?

Steve Pereira describes the concept of value stream mapping, and how it, and related techniques, can be used to improve the flow of practically any process from product ideation to delivery and customer experience.  Steve is the founder of Visible, and is obsessed with making tech human, and leveraging it to deliver continuous value. ResourcesBook: Project to Product by Dr. Mik KerstenFree eBook: Flow Engineering by Steve PereiraValue Stream Management CourseNewsletter for upcoming book: Inside OutGuest: Steve PereiraLinkedInEmail: steve@visible.isUltimate linkWatch this episode on YouTube

Mobile App Talks EP13 - Dependency Management in Mobile Apps --- Send in a voice message: https://anchor.fm/blace-talk/message

This episode is a replay of my Scrum Day Europe 2021 presentation, Scrum Isn't Enough: Why DevOps is essential for Agile success.When Scrum was formulated, it was seen as a “wrapper” for more technical agile practices, such as Extreme Programming. A conscious choice was made to focus on the relationship between software developers and management. It was assumed that Scrum would be used to promote more technical developer practices, which Scrum leaves unaddressed. DevOps not only works hand-in-glove with Scrum to fill in these missing gaps, it is more and more seen as an essential tool for Agile success.Resources:Scrum Day Europe 2021Presentation slidesBook: Agile Software Development with ScrumThe 2021 Scrum GuideBook: The Phoenix ProjectBook: The Unicorn ProjectFree email Lean CD BootcampWatch the video of this episode.

Wer sein Studium abbricht, um ins Denoland zu gehen, hat sicher eine interessante Geschichte zu erzählen. Aus diesem Grund haben wir in dieser Folge Luca Casonato zu Gast, der uns von Deno erzählt, einer Laufzeitumgebung für JavaScript und TypeScript. Deno wurde 2018 von Ryan Dahl, dem Schöpfer von Node.js, auf der JSConf EU vorgestellt (hier geht's zur Aufzeichnung des Talks). Er beschreibt darin fundamentale Schwächen von Node, die er bereut und nun mit Deno lösen möchte. Unser Gast Luca arbeitet als eine der wenigen Personen hauptsächlich am Projekt und spricht mit uns über die größten Unterschiede zwischen den beiden Varianten. In dieser Folge streifen wir das Dependency-Management von Deno, seine Eigenschaften als opinionated Runtime und seine hohe Sicherheit gegenüber Node. Hier kommt ihr zu Lucas Webseite und seinem Twitter-Profil. Auf der Webseite von Deno könnt ihr euch noch mehr Infos einholen. Picks of the Day Luca: Die Deno-Extension für Visual Studio Code mit cooler Autocompletion. Fabi: JSConf Vortrag von Philip Roberts: What the Heck is the Event Loop anyway. Ein Must-Watch für alle Javascript-EntwicklerInnen. Ihr habt euch schon immer gefragt, was die Event Loop ist bzw. wie sie funktioniert? Dann ist das Video genau richtig. Ansonsten ist es aber auch nochmal die perfekte, unterhaltsame Auffrischung, um die Event Loop komprimiert in 25 Minuten erklärt zu bekommen. Schreibt uns! Schickt uns eure Themenwünsche und euer Feedback. podcast@programmier.bar Folgt uns! Bleibt auf dem Laufenden über zukünftige Folgen und virtuelle Meetups und beteiligt euch an Community-Diskussionen. Twitter Instagram  Facebook Meetup YouTube Musik: Hanimo 

В релиз ушёл kotlinx.serialization и его теперь можно спокойно подключать в ваш проект. Зачем он нужен, что в нём классного и как он выглядит на фоне gson и moshi мы обсудили в этом выпуске.Кроме этого мы решили обсудить извечную проблему "написать самому или подключить библиотеку". Когда лучше обойти новые библиотеки стороной, а когда вполне нормальная идея не делать миллионное решение проблемы, когда она уже давно решена? И много других вопросов и ответов уже здесь! 00:00:18 - kotlinx.serialization в релизе.00:25:12 - Начало обсуждения статьи Избегайте внедрения внешних библиотек в свой проект.00:27:53 - Влияние dependencies на размер приложения.00:35:07 - Сложность поддержки кода в связке с dependencies.00:38:57 - Время на изучение библиотеки.00:50:00 - Скорость сборки и её зависимость от библиотек.00:50:55 - Что если в библиотеке баги?00:53:27 - Уязвимости, которые привносят dependencies.00:55:10 - Поддержка библиотеки.00:57:17 - Присутствия библиотеки во всех слоях: нужно ли это ограничивать? 00:58:37 - Обращаем внимание на ограничения библиотеки.00:59:39 - Что если gradle файл с зависимостями становится слишком большим? 01:00:00 - Чек-лист вопросов перед внедрением библиотеки.Комментарии и пожелания можно оставлять в нашем телеграмм чате.

פרק מספר 67 של באמפרס (390 למניין רברס עם פלטפורמה) - רן, אלון ודותן נפגשים שוב ב-27 במאי 2020 אחרי מלא זמן ללא באמפרס - תקציר העונה הקודמת (Previously on Bumpers) - ארני חזר למולדת? תודה (שוב) לזהר זקס, הבאמפרס הקודם היה לרגל 1 באפריל למי שלא שם לב (המציאות הייתה אפילו יותר מוזרה מהרגיל מאז אז יש מצב שפיספסתם), וקצת אחרי הקלטת הפרק הקורונה תפסה גם בישראל, אז לקח זמן עד שהילדים חזרו לבתי הספר (בינתיים?) ואפשר לקבל כמה שעות שקטות ולהקליט.אז - באמפרס: רן, אלון ודותן עם סקירה של קצרצרים על טכנולוגיות ודברים מעניינים מהזמן האחרון (ולרגל הפער - אולי גם קצת יותר ותיקים יותר הפעם) - ספרים, פרוייקטים, Repos ב-GitHub וכו’ (פרס למתמידים עד הסוף - יש גם מצחיקים!)רן - נתחיל עם דו”ח ש GitLab פרסמו בשם The Future of Work is Remoteאולי היה פחות מעניין בשנה שעברה, אבל מאוד מעניין עכשיו בגלל התקופה, כי כולנו והתעשייה מסביב עובדים מהביתמה האינטרס מאחוריי היוזמה? GitLab היא חברה מבוזרת לחלוטין, למיטב ידעתי (רן) אין להם משרדים בכלל (או משהו ממש משני), ומבחינתם הם רוצים לבנות את עצמם כ”החברה המבוזרת”נכון שהם לא הראשונים, אבל הם ממתגים את עצמם כ”חברת ה-Remote” ורוצים להיתפס כ-Thought Leaders בתחום - אז יצרו את הסקר הזה, כשבגדול - התגליות אינן סופר מפתיעות אבל שווה לקרוא:המוטיבציה לעבודה מהבית - אם אולי בעבר המוטיבציה העיקרית לעבודה מרחוק הייתה היכולת להיות Digital Nomad - ללא בית, יכולת לעבוד מכל העולם, גם אם זה אומר לטוס לתאילנד, לשכב על החוף ולהמשיך לעבוד - היום המצב הוא לא כזה (לא בטוח שזה היה המצב גם בעבר, אל זו הייתה התדמית).באופן מפורש - רוב האנשים שעובדים מהבית עושים זאת בשביל הנוחות שלהם - יותר זמן עם המשפחה, פחות זמן על הכבישים, יותר זמן לספורט וכו’.לא מפתיע בטירוף - אנחנו שלושתינו (רן, דותן, אלון) בסיטואציה הזו (אולי פחות שוכבים על החוף בתאילנד, וגם אם היינו עושים את זה לא היינו אומרים . . .), אבל זה נחמד לראות את זה במספרים.הדבר השני שתפס את תשומת ליבי (רן) הוא מה שהם מכנים “Remote work levels the playing field”, ובעברית - שיוויון הזדמנויות.בהתחלה חשבתי שזה בסגנון “מי שגר בקריית שמונה ורוצה לעבוד בחברה שממוקמת בתל אביב, אז עכשיו הוא יכול וקודם לא ממש”, אבל הם מדברים על משהו אחר (אולי גם זה, אבל לא רק) - הם בעיקר מדברים על אנשים עם מוגבלויות מסוגים שונים - נכות פיסית, מוגבלות נפשית כלשהי, מחלה וכו’ - שעכשיו מרגישים שהרבה יותר קל להם להשתלב בחברה שהיא מבוזרת.לא נדרש ה-Commute, בבית הרבה יותר לתפקד, אולי יותר קשה במצבים חברתיים מסויימים שכאשר עובדים מרחוק יותר קל בהם - הם ממש ציינו מספר של 12% שמבחינתם זהו היתרון.דו”ח מעניין, יש עוד מלא סעיפים.ספרייה בשם Diagrams (או Diagram as Code) - ספריית Python 3 (רק 3) שמאפשרת לכם לכתוב קוד ב - Python, להריץ אותו - וזה מג’נרט (Generates) דיארגמה - ודיאגרמות די יפות.אפשר לבחור את ה-Theme (למשל AWS, או ארכיטקטורה) ואז יש כל מיני ספריות שיודעות לייצג את האלמנטים האלה בצורה יפה, ואתם למעשה כותבים קוד Python-י, שדי קל להבין אותו (ה-API עצמו הוא מאוד ב-High-level - אתם יוצרים Lists ו-Instances של Classes, אבל בסוף  זה הכל מאוד קריא) . . . מריצים - ונוצרת דיאגרמה.נחמד  וניתן להרחבה: אתם יכולים לכתוב ספריות משלכם עם אלמנטים משלכם, אם למשל חסר לכם אלמנט לדוגמא של GPU או Hard disc שלא קיים, אתם יכולים פשוט לצייר אותו בעצמכם (בהנחה שיש לכם את הכשרון) ולהוסיף את זה כמחלקה בתוך הכלי.בזמן האחרון יוצא לי הרבה מאוד להתעסק בנושאי Data Science ו-Machine Learning בשביל פרויקט שאני עובד עליו, והאייטמים הבאים הם מהאיזור הזה - סדרה של סרטונים די-קצרצרים ומאוד נחמדים, שמסבירים כל מיני אלמנטים ב - Data Science בצורה אינטואיטיבית ונחמדהדברים כמו K Nearest Neighbors או Confusion Matrix ו-K means clustering, וכו’זו סדרת סרטונים באורך של לא יותר מחש דקות כל אחד, כשכל וידאו מסביר את אחד ממושגי הייסוד בצורה ויזאולית, וזה נחמד אם אתם רוצים להיזכר או להכיר מושגים חדשים ברמה יחסית שטחית אבל מספיק טובה בשביל שיחה.זה לא שאתם עכשיו הולכים לממש K Nearest Neighbors לפי הוידאו, אבל זה מספיק טוב בשביל להכיר, והייתי ממליץ.החסרון היחיד - לדובר יש מבטא סיני כבד, ואעפ”י שזה באנגלית קצת קשה להבין; מצד שני יש כתוביות  אז אפשר גם לקרוא, ואחרי שמתרגלים לאנגלית שלו אז אפשר לגמרי להבין.מסתבר שיש אנשים (דור Y?) שעבורם להקשיב ולקרוא את הכתוביות במקביל עוזר להתרכז . . נסו.שני מאמרים שמהווים Intro עבור Framework בשם Keras - אחד ה-Frameworks הבולטים בעולם הזה, יש לו כמה מימושים (ואחד הבולטים בהם הוא של TensorFlow) - זה API שאומר “ככה אתם בונים מודלים של רשת נוירונים”, למיטב ידיעתי (רן) הוא עוסק רק ברשתות נוירונים אבל יכול להיות שיש עוד איזורים.החל מגרסא 2, TensorFlow יישר את עצמו לפי הממשק של Keras כשגם ל Pytorch יש גרסא ל-Keras וגם ל-Framework המקביל של Microsoft יש ממשק כזה (Databricks) - וניתקלתי בשני Tutorials נחמדים שמסבירים איך אפשר לעשות דברים ב-Kerasאחד מהם מגיע מהפרספקטיבה של Researcher: נניח שאתה צריך לממש שכבה מיוחד כלשהי במודל (למשל רשת נוירונים עם שכבה מאוד ספציפית ואלגוריתם מאוד מיוחד משלך) - המדריך הזה מלמד קצת על ה-Internals של Keras ואיך לכתוב Custom Code, בין אם זה Custom Layer או Custom metric או Loss Function וכל הדברים האלהה-Tutorial השני בא מפרספקטיבה של מהנדס: הוא רוצה להשתמש ב - Keras, בכלים הקיימים - לא לכתוב Components חדשים אלא להשתמש במה שקיים - והמדריך הזה בא ומראה בצורה מאוד יפה איך בתור מהנדס, Data Science Engineer, אתה יכול להתשמש ב- Keras.ואחרון בעניין הזה - המלצה על Weekly חדש שרן הצטרף אליו (וממנו הגיעו רוב הלינקים הקודמים) - אם אתם מתחום ה-Data Science ו-Machine Learning אתם אולי כבר מכירים ואם אתם רוצים להיכנס לתחום אז אני ממליץ על Data Science Weekly Newsletter, שזה ובכן - Weekly שמגיע כל שבוע עם קישורים, כמו הרבה אחרים - וערוך ברמה גבוהה.(אלון) משהו בקורונה הזה גרם לך לעבור להיות Data Scientist ולהתעסק הרבה ה-Python . . .(רן) זה התחיל קצת לפני הקורונה ולא קשור - אבל התחלתי לעסוק בעבודה בפרויקט שקשור לזה, ולעזור לצוות של Data Scientists להרים איזשהו פרוייקט - אז נכנסתי “לגוב האריות” והתחלתי ללמודקראתי גם ספר, שאני לא ממליץ עליו… אקרא עוד כמה ואז אדע על מה אני ממליץ(אלון) תכל’ס, באמפרס יותר מתאים לדברים שאתה לא רוצה להמליץ עליהם . . “זהירות! מהמורה! דלג!” (Bumpers Anti-Patterns Edition?)(רן) מה שקרה זה שהוצאת ספרים בשם Springer פרסמו בתחילת תקופת הקורונה הרבה מאוד מהספרים שלהם (שבדרך כלל מאוד יקרים) להורדה בחינם (לעותקים אלקטרוניים) - הורדתי משהו כמו 20 והתחלתי לקרוא (בינתיים אחד, אז יש עוד הרבה עבודה . . .), וחלק באמת בתחום של Data Science, לא כולם - וזה ספציפית ספר קצת “חלבי” ולא ממש מומלץ, כבר מסיים ועובד לספר הבא, אם תיהיה המלצה כמובן שנוסיף בחום.אז מכאן זה מגיע - בזמן האחרון יצא לי להתעסק הרבה בתחום של Data Science, עם Python ככלי, בעיקר כדי לעזור לאחד הפרויקטים שקורים אצלנו בעבודה.דותן - לפני שבוע או שבועיים יצא Deno . . . מישהו שמע?(רן) כן, כבר די הרבה זמן באוויר, Benjamin כתב על זה כמה פוסטיםאז 1.0 יצא לפני שבוע או שבועיים (13 במאי 2020)(אלון) רק שבועיים? מדברים על זה כבר שנתיים.(דותן) כן, אז עכשיו זה זה באמת 1.0, וכל הרשת התמלאה בכל מיני Hype מטורף של “לזרוק את Node ולעבור ל-Deno”, כמו הרבה פעמים שדברים כאלה קורים.(אלון) אז זה מה שצריך לעשות?(דותן) כן, המלצה חמה - זרוק ועבור. עכשיו תתחיל לתקן . . .אז Deno זה “Runtime ל-JavaScript”, זה ה-Tagline הפורמלי (ב-TypeScript), מהיוצר של Node.js שיצא משם, ישב בבית שנתיים ובנה לאט ובשקט (או ברעש) - וזה הגיע לגרסא 1.0.מה יצא? Runtime שבנוי ב-Rust, שיותר קל לעשות לו Maintenance, יותר Secure וכו’ - נראה שהוא לא עשה המון מהטעויות שהוא עשה בפעם הראשונה, לפחות ככה הוא מעיד . . .חזק לכיוון של TypeScript ומרגיש קצת כמו Go מבחינת ה-Dependency Management. עוד משהו (ואולי זה רק האלמנט של השעה . . .) - אני מרגיש שמבחינת Ecosystem ומודולים זה בכיוון של “ספרייה אחת טובה במקום עשר ספריות בינוניות”, שזה גם שינוי מרענן מ Node.js(אלון) חכה חכה . . . זה JavaScript(דותן) כן, אולי זה באמת עניין של השעה . . .(אלון) ברגע שזה הופך פופלארי מיד יש לך ארבע ספריות לכל דקה . . .(דותן) זה מאוד תלוי בקהילה שנוצרת - אם נוצרת קהילה בצורה מסויימת, אם לוקחים את Rust

Dependency management in Python has taken a long and winding path, which has led to the current dominance of Pip. One of the remaining shortcomings is the lack of a robust mechanism for resolving the package and version constraints that are necessary to produce a working system. Thankfully, the Python Software Foundation has funded an effort to upgrade the dependency resolution algorithm and user experience of Pip. In this episode the engineers working on these improvements, Pradyun Gedam, Tzu-Ping Chung, and Paul Moore, discuss the history of Pip, the challenges of dependency management in Python, and the benefits that surrounding projects will gain from a more robust resolution algorithm. This is an exciting development for the Python ecosystem, so listen now and then provide feedback on how the new resolver is working for you.

Have you ever ended up in a situation where you need to do a small change to an old TS/JS app that no-one has touched in months? Quite often, in these situations, the app does not work anymore, because of a change in a dependency or a dependency of a dependency. This is why http://npmplease.com/ exists. The JS ecosystem is inherently broken. There are cases where malicious packages have made thousands or millions of projects stop working. In this presentation, Olavi will talk about how to avoid ending up in a huge mess with your node_modules, and how to handle dependencies in a future-proof way without loosing your time and energy waiting for “npmplease”. Presenter: Olavi Haapala

Have you ever ended up in a situation where you need to do a small change to an old TS/JS app that no-one has touched in months? Quite often, in these situations, the app does not work anymore, because of a change in a dependency or a dependency of a dependency. This is why http://npmplease.com/ exists. The JS ecosystem is inherently broken. There are cases where malicious packages have made thousands or millions of projects stop working. In this presentation, Olavi will talk about how to avoid ending up in a huge mess with your node_modules, and how to handle dependencies in a future-proof way without loosing your time and energy waiting for “npmplease”. Presenter: Olavi Haapala

TeamUp: https://www.teamup.com/Jordi's Twitter: twitter.com/seldaekComposer docs: https://getcomposer.org/doc/Private Packagist: https://packagist.com/Jordi's Composer Deep Dev talk at Laracon EU: https://www.youtube.com/watch?v=q3UfxubW_PUComposer Best Packages talk by Nils: https://www.youtube.com/watch?v=EpvihKaQyLsJordi's OSS wish list: http://seld.be/wishlistBalvenie scotch: https://www.thebalvenie.com/Transcription sponsored byLarajobsEditing sponsored byTighten

In this episode, we embarked on a fascinating journey of despair and hope with Sam Boyer (@sdboyer), the author of the Go Dep experiment, and discussed all things dependency management - why it doesn't work, and what can be done to make it a little more transparent and easier to work with.Go dep commit officially retiring the project, made on the day of our podcast was airedThe notorious blog post about package manager (which Baruch uses in all his talks now)Sam's take on the Go Dep experimentSemantic VersioningRuss Cox on SATJFrog Xray analyzing the security and licensing selections signals of the dependency managementConfusion Matrix definitionConfusion Matrix explained^1.2.0 is a lie

Dependency management, despite its importance, does not get the attention it deserves and is often a bit haphazard and less structured than it could be. In this playbook, we suggest a lightweight way to identify and manage dependencies. We explain why to do it, how to do it, what good looks like, and the most important dos and don'ts. Detailed discussion here: https://thedigitalbusinessanalyst.co.uk/how-to-manage-dependencies-1551355b9025. Show Notes Example and Template here: https://thedigitalbusinessanalyst.co.uk/how-to-manage-dependencies-1551355b9025 Expanded show notes and leave questions or comments for this episode at: https://burnupmedia.com/2019/06/26/ep16-tldr-dependency-management/ – More information at https://www.theburnup.com This podcast produced by Burn Up Media Ltd under under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License. Further Information at: https://creativecommons.org/licenses/by-nc-nd/4.0/

Modern web development involves a complicated toolchain for managing dependencies. One part of this toolchain is the bundler, a tool that puts all your code and dependencies together into static asset files. The most popular bundler is webpack, which was originally released in 2012, before browsers widely supported ES Modules. Today, every major browser supports The post Pika Dependency Management with Fred Schott appeared first on Software Engineering Daily.

Modern web development involves a complicated toolchain for managing dependencies. One part of this toolchain is the bundler, a tool that puts all your code and dependencies together into static asset files. The most popular bundler is webpack, which was originally released in 2012, before browsers widely supported ES Modules. Today, every major browser supports The post Pika Dependency Management with Fred Schott appeared first on Software Engineering Daily.

Modern web development involves a complicated toolchain for managing dependencies. One part of this toolchain is the bundler, a tool that puts all your code and dependencies together into static asset files. The most popular bundler is webpack, which was originally released in 2012, before browsers widely supported ES Modules. Today, every major browser supports The post Pika Dependency Management with Fred Schott appeared first on Software Engineering Daily.

Modern web development involves a complicated toolchain for managing dependencies. One part of this toolchain is the bundler, a tool that puts all your code and dependencies together into static asset files. The most popular bundler is webpack, which was originally released in 2012, before browsers widely supported ES Modules.Today, every major browser supports the ES Module system, which improves the efficiency of JavaScript dependency management. Snowpack is a system for managing dependencies that takes advantage of the browser support for ES Modules. Snowpack is made by Pika, a company that is developing a set of web technologies including a CDN, a package catalog, and a package code editor.Fred Schott is the founder of Pika and the creator of Snowpack. Fred joins the show to talk about his goals with Pika, and the ways in which modern web development is changing.

Igor Lankin führt in dieser Folge in die Programmiersprache Go ein, die 2009 von Google vorgestellt wurde und verglichen mit C ähnliche Geschwindigkeiten bei niedriger Komplexität ermöglichen soll. Nach einer Einführung in die wesentlichen Elemente wie Slices und Structs geht es um Exception Handling und Dependency Management. Igor erklärt zudem, warum Go insbesondere für Multi-Core Programmierung geeignet ist und wo aus seiner Sicht Go (noch) Probleme hat.

Highlights of Dr Jill Thistlethwaite’s conversation with Dr Malcolm Dobbin on the management of codeine dependency. For more information about the changes to codeine visit https://www.nps.org.au/medical-info/clinical-topics/over-the-counter-codeine-changes-to-supply#resources?utm_medium=link-external&utm_source=18-02-05&utm_campaign=codeine&utm_content=CodeinePodcast2

Nothing in Business Continuity Management (BCM) or Disaster Recovery Planning (DRP) stands alone; everything has a dependency on some level. On this weeks show we will talk to Alvaro Orrantia a Senior Director for one of Canada's largest Financial Institutions, who will talk to us about dependencies and dependency management. We'll learn how to identify our program - and organizational - dependencies and provide tips on how we can manage and maintain our dependencies. We'll talk about the dependency link between other organizational programs and processes and how they need to work together to reach the same goals; to prepare us for disasters. We'll also talk about the link between Information Security (IS) and Business Continuity (BC) and how there is a dependency between the two processes. It's a very informative show with many

Nothing in Business Continuity Management (BCM) or Disaster Recovery Planning (DRP) stands alone; everything has a dependency on some level. On this weeks show we will talk to Alvaro Orrantia a Senior Director for one of Canada's largest Financial Institutions, who will talk to us about dependencies and dependency management. We'll learn how to identify our program - and organizational - dependencies and provide tips on how we can manage and maintain our dependencies. We'll talk about the dependency link between other organizational programs and processes and how they need to work together to reach the same goals; to prepare us for disasters. We'll also talk about the link between Information Security (IS) and Business Continuity (BC) and how there is a dependency between the two processes. It's a very informative show with many

Links =============== Functional Swift Conference Berlin - http://www.funswiftconf.com Functional Swift Buch - https://www.objc.io/books/functional-swift/ Swift Talk - https://talk.objc.io Pointfree (Functional Swift Talk) - https://www.pointfree.co The Manifest - https://manifest.fm Cocoapods - https://cocoapods.org Pod Search Alfred - https://github.com/BenchR267/Pod-Search-Alfred apodidae - https://github.com/kiliankoe/apodidae Carthage - https://github.com/Carthage/Carthage dylib WWDC 2017 - https://developer.apple.com/videos/play/wwdc2017/413/ Akronymisierbar - https://feed.akronymisier.bar Cargo Edit - https://github.com/killercup/cargo-edit detect.location - https://github.com/KrauseFx/detect.location Uber Reaktion auf Permissionsänderung in iOS 11 - https://twitter.com/viticci/status/910606895320326144 Attabench - https://github.com/attaswift/Attabench Optimizing Collections in Swift - https://www.objc.io/books/optimizing-collections/ Ben auf Twitter - https://twitter.com/benchr Dom auf Twitter - https://twitter.com/swiftpainless Vincent auf Twitter - https://twitter.com/regexident Hallo Swift auf Twitter - https://twitter.com/hallo_swift SwiftDe-Slack - http://slack.swiftde.net Hallo Swift Webseite - http://hallo-swift.de Hallo Swift auf iTunes - https://itunes.apple.com/de/podcast/hallo-swift/id1225721421?mt=2

Alex and Andrew discuss A/B testing. What it is, how it works, and how to stay on top of it. Next, they discuss dependency management. What is it and why should you use it? How can you setup dependency management? Show Notes: iOS Project Setup with Cocoapods video: https://www.youtube.com/watch?v=1SZfSXqQcZs&t=4s Learn more about AB testing best practices here: https://m.smartcloud.io/ab-testing-best-practices-in-ios-apps-2f04ab4f642e Wanna chat with other smart iOS developers? Sign up for our free forum: https://forum.insideiosdev.com

Sam Boyer joined the show to talk about dependency management, building community consensus, and other interesting Go projects and news.

Sam Boyer joined the show to talk about dependency management, building community consensus, and other interesting Go projects and news.

Sam Boyer joined the show to talk about dependency management, building community consensus, and other interesting Go projects and news.

Bei dieser Episode handelt es wie der Titel schon verrät um eine Spezialepisode rund um das Thema iOS Entwicklung. Andre lässt sich dieses mal entschuldigen und Thomas hat Christoph Wimberger zu Gast mit dem er über die verschiedensten Themenbereiche spricht. Es geht dabei um Dependency Management, Build Automatisierung, Swift, CoreDate, Multithreading und vieles mehr.

Peter Bourgon joined the show to talk about Go kit, microservices, Go in the enterprise, dependency management, and writing Go packages.

Peter Bourgon joined the show to talk about Go kit, microservices, Go in the enterprise, dependency management, and writing Go packages.

Peter Bourgon joined the show to talk about Go kit, microservices, Go in the enterprise, dependency management, and writing Go packages.

1:40 - Introducing Uri Goldshtien Meteor Development Group Apollo Library Github Twitter 6:00 -Intro to Graph QL http://www.graphql.com/ Community page 28:40 - Live demo of using Graph QL 35:00 - Demo using example apps Instagraph Blog posts

1:40 - Introducing Uri Goldshtien Meteor Development Group Apollo Library Github Twitter 6:00 -Intro to Graph QL http://www.graphql.com/ Community page 28:40 - Live demo of using Graph QL 35:00 - Demo using example apps Instagraph Blog posts

1:40 - Introducing Uri Goldshtien Meteor Development Group Apollo Library Github Twitter 6:00 -Intro to Graph QL http://www.graphql.com/ Community page 28:40 - Live demo of using Graph QL 35:00 - Demo using example apps Instagraph Blog posts

In this mini episode, we talk with the lovely Kelly Shushter about Internal Library Dependency Management. Kelly is a GDE, the Director of Women Who Code (Denver chapter), a developer at Thoughtbot, a mind blowingly good AndroidDev and just an all round boss of everything. She gives us the rundown explaining different strategies for maintaining and managing internal libraries in your organization/company. http://fragmentedpodcast.com/episodes/40

02:28 - Ruby in a Polyglot Architecture (Panel Experience) 04:21 - Does Ruby do well or not in the microservices area? Is Ruby keeping up? 07:30 - What are areas where Ruby still beats other languages? Speed and Momentum Dependency Management CPAN Bundler npm 13:12 - Polyglotting Architecture if Only Using Ruby for Build Tools, Deployment Tools, etc.? “Deployment is part of the code.” Capistrano rake 16:09 - Error Messages 18:20 - Tradeoffs in a Polyglot Architecture (Negatives) Context Switching AWK DSLs 34:35 - Learning Programming Ruby as a First Language? What is a good language for beginners? Smalltalk Scheme Python 41:24 - Mixing Languages

02:28 - Ruby in a Polyglot Architecture (Panel Experience) 04:21 - Does Ruby do well or not in the microservices area? Is Ruby keeping up? 07:30 - What are areas where Ruby still beats other languages? Speed and Momentum Dependency Management CPAN Bundler npm 13:12 - Polyglotting Architecture if Only Using Ruby for Build Tools, Deployment Tools, etc.? “Deployment is part of the code.” Capistrano rake 16:09 - Error Messages 18:20 - Tradeoffs in a Polyglot Architecture (Negatives) Context Switching AWK DSLs 34:35 - Learning Programming Ruby as a First Language? What is a good language for beginners? Smalltalk Scheme Python 41:24 - Mixing Languages

02:28 - Ruby in a Polyglot Architecture (Panel Experience) 04:21 - Does Ruby do well or not in the microservices area? Is Ruby keeping up? 07:30 - What are areas where Ruby still beats other languages? Speed and Momentum Dependency Management CPAN Bundler npm 13:12 - Polyglotting Architecture if Only Using Ruby for Build Tools, Deployment Tools, etc.? “Deployment is part of the code.” Capistrano rake 16:09 - Error Messages 18:20 - Tradeoffs in a Polyglot Architecture (Negatives) Context Switching AWK DSLs 34:35 - Learning Programming Ruby as a First Language? What is a good language for beginners? Smalltalk Scheme Python 41:24 - Mixing Languages

In dieser Vorlesung diskutiere ich mit Reinhard Pötz, der langjähriger Entwickler am Apache Cocoon Projekt ist, und entsprechend viel Erfahrung in diesem Kontext hat, Automatisierung in der Software Entwicklung.Konkret besprechen wir was im Lebenszyklus der Anwendungsentwicklung überhaupt automatisiert werden kann und die Vorteile dieser Automatisierung. Es werden Build-Tools vorgestellt und am Beispiel von Maven 2 gezeigt, wie moderne Softwareentwicklung von Automatisierung profitieren kann.Wir diskutieren Archetypen, Dependency Management, Generierung von Reports (Tests, Checkstyle) sowie Dokumentation. Zuletzt behandeln wir das Konzept "Continuous Integration" und wie diese in erfolgreichen und großen Projekten eingesetzt wird.Vorlesung als m4a