Powered by RND
PodcastsTechnologieConTejas Code

ConTejas Code

Tejas Kumar
ConTejas Code
Nieuwste aflevering

Beschikbare afleveringen

5 van 81
  • Sacha Greif: How to Understand Developers through Surveys
    Links- Codecrafters (partner): https://tej.as/codecrafters- State of Devs survey: https://stateofdevs.com/en-US- Sacha's post on Dev.to: https://dev.to/sachagreif/how-the-devographics-surveys-are-run-2023-edition-1p6a\- Episode with Ujjwal Sharma (TC39 Chair): https://www.linkedin.com/posts/tejasq_contejas-code-ujjwal-sharma-how-javascript-activity-7185637709128884225-joHP- Sacha on X: https://x.com/SachaGreif- Sacha's website: https://sachagreif.com/- Tejas on X: https://x.com/tejaskumar_SummaryIn this discussion, we talk deeply with Sacha Greif, the founder of the popular State of JS, State of CSS, State of WebDev AI, and State of Devs surveys. We understand:1. What it takes to create a great survey2. How to process and visualize the data3. Interesting insights and trends from the latest surveysFinally, we explore the biggest lessons Sacha learned from running the surveys for the past 7 years.Chapters00:00:00 Introduction00:06:30 Goals & Scope of the Surveys00:09:15 Why the Surveys Resonat00:18:11 Survey Design00:23:20 Crafting Effective Survey Questions00:26:19 The Open Source Stack00:30:34 Monetization Strategy00:34:25 Potential Future Surveys00:36:04 Subjective Opinion vs. Objective Truth in Data00:37:42 Handling Bias, Demographics, and Language Barriers00:41:50 Optional Questions, Data Privacy, and Transparency00:48:33 Addressing Criticism: Representation and Influencer Lists00:57:20 Post-Survey: Data Analysis and Visualization01:04:19 The Technical Infrastructure Behind the Surveys01:08:13 Simplicity vs. Complexity in Development01:09:20 Biggest Traffic Drivers & YouTuber Influence01:11:08 Communicating Context and Avoiding Misinterpretation01:13:10 Key Finding 1: Things Change Slower Than Perceived01:15:13 Why the Disconnect Between Perception and Reality?01:19:26 Key Finding 2: State of Web Dev AI & "Vibe Coding" Reality01:27:48 Key Finding 3: The "Boomerang Effect"/Hype Cycle of Tools01:35:13 How Tools Supersede Each Other (Webpack/Vite, Node/Bun)01:42:12 How Established Tools Compete & Adapt01:44:17 Most Important Lessons Learned Running the Surveys01:49:46 Hope for the Surveys' Future Impact01:52:45 Call to Action: Take the State of Devs Survey Hosted on Acast. See acast.com/privacy for more information.
    --------  
    1:57:18
  • Alexander Lichter: The State of Modern Web Tooling
    Links- Codecrafters (sponsor): https://tej.as- Alex: https://www.lichter.io/- Alex on YouTube: https://www.youtube.com/@TheAlexLichter- Alex on X: https://x.com/TheAlexLichter- VoidZero: https://voidzero.dev/- Vite Plus: https://i.redd.it/l0d9yemja1pe1.jpeg- Talk including VitePlus: https://youtube.com/watch?v=5mn3EpWCcJs&t=16353s- Rolldown Vite: https://vite.dev/rolldown- Oxc Custom Lint Plugins discussion: https://github.com/oxc-project/oxc/discussions/10342#discussioncomment-12828320Previous Episode- Apple: https://podcasts.apple.com/us/podcast/alexander-lichter-how-to-get-the-most-out-of-vue-js-and-nuxt/id1731855333?i=1000678873395- Spotify: https://open.spotify.com/episode/5NdqcW2GnQ57IetEKD1dua- YouTube: https://www.youtube.com/watch?v=Y32Ko_CkbAISummaryIn this conversation, Alexander Lichter and I discuss the evolution of JavaScript tooling, focusing on the significance of VoidZero and Vite. We explore the need for a unified JavaScript toolchain, the challenges faced by existing tools like Webpack, and the importance of user experience in development tools. We also touch on the lessons learned from the Rome project and the future of VoidZero, including its funding and vision for open-source development. Chapters00:00:00 Alex Lichter00:06:33 The Evolution of JavaScript Tooling00:09:34 Understanding VoidZero and Its Purpose00:12:15 The Need for a Unified JavaScript Toolchain00:15:16 Vite: The Cornerstone of Modern Development00:18:21 Comparing Vite and Webpack00:21:17 User Experience in Development Tools00:24:34 Lessons from Rome and Biome00:27:14 Funding and Future of VoidZero00:35:03 Introduction to Rolldown and Its Origins00:36:00 Understanding Rolldown's Purpose and Features00:39:34 The Transition from Rollup to Rolldown00:42:46 The Need for Speed in Development00:46:31 The Role of Plugins in Rolldown00:49:53 OxLint: A Game Changer for Linting00:57:33 Exploring the OxC Toolkit00:59:48 Clarifying Relationships in the Toolchain01:03:43 Type Checking Strategies and Future Directions01:05:21 Understanding Isolated Declarations in TypeScript01:06:20 Performance Comparison: OXC vs SWC01:09:11 The Role of Code Formatting in Development01:12:18 Extensibility and Plugin Architecture of OXC01:15:21 Dev Server Performance and Cold Starts01:21:35 The Role of Developer Relations at VoidZero01:27:24 Encouraging Contributions from the Community01:31:19 Collaboration Between Different Developer Communities01:33:21 Future Prospects and Final Thoughts Hosted on Acast. See acast.com/privacy for more information.
    --------  
    1:37:26
  • Kent C. Dodds: Model Context Protocol (MCP) and how it changes UX
    Links- Codecrafters (sponsor): https://tej.as/codecrafters- Epic AI: https://epicai.pro/- MCP: https://www.anthropic.com/news/model-context-protocol- Kent on X: https://x.com/kentcdodds- Tejas on X: https://x.com/tejaskumar_SummaryIn this episode, we explore the evolution of user interaction, particularly in the context of AI and the Model Context Protocol (MCP). We discuss how user experiences are shifting from traditional UI elements to more natural language interactions, akin to conversing with a human assistant. We also discuss the potential of AI to enhance user experiences and the implications of MCP in creating more efficient workflows. Kent shares his vision for a Jarvis-like AI assistant that could revolutionize how we interact with technology, emphasizing the importance of understanding and implementing MCP for developers and users alike. We also talk about security concerns, particularly tool poisoning, highlighted as significant issues that need addressing. Chapters00:00:00 Intro00:03:35 The Evolution of User Interaction00:07:41 AI and the Future of User Experience00:11:45 Building the Future: Jarvis and MCP00:15:34 MCP: Understanding the Model Context Protocol00:28:28 The Practical Implications of MCP00:42:14 Understanding MCP and LLM Interactions00:47:12 The Evolution and Maturity of MCP Spec00:52:07 The Future of MCP and Its Adoption01:01:07 Security Concerns in MCP: Tool Poisoning01:05:20 MCP's Impact on Digital Strategies01:22:25 The Future of AI and MCP01:28:18 User Experience and Adoption of AI01:33:44 How to Get Started with MCP01:40:50 Building MCP Servers and Best Practices01:45:46 Exploring AI Developments Beyond MCP01:52:45 Agent Communication and Tool Management01:57:31 Where to find Kent C. Dodds Hosted on Acast. See acast.com/privacy for more information.
    --------  
    2:01:25
  • Kendo UI Team: How to build quality design systems, Kendo UI, collaboration
    Links- Kendo React: https://www.telerik.com/kendo-react-ui/components/free- Kathryn's Book: https://www.telerik.com/campaigns/design-story/ebook--foundations-of-design-for-developers- Progress: https://progress.com - Sam on X: https://x.com/samidip- Kathryn on X: https://x.com/kathryngrayson- Kiril on X: https://x.com/kirchoniSummaryIn this episode, we talk with Sam Basu, Kathryn Grayson Nanz, and Kiril to explore Kendo UI and Kendo React. We discuss the evolution of UI libraries, the engineering behind Kendo's components, and the importance of accessibility in modern applications. The conversation delves into the unique offerings of Kendo React, particularly its data grid and virtualization techniques, as well as the design considerations that enhance user experience. The introduction of the Theme Builder is highlighted as a tool that bridges the gap between design and development, allowing for seamless collaboration and customization. We also cover the importance of collaboration between designers and developers, the significance of design tokens, and the incremental adoption of Kendo React in existing applications. Chapters00:00:00 Intro00:04:24 Kendo UI and Progress00:07:19 Kendo React's Unique Offerings00:10:35 The Engineering Behind Kendo UI Components00:13:10 Kendo React: A Case Study in UI Libraries00:16:19 Accessibility and Compliance in Kendo React00:19:35 Deep Dive into Kendo React's Data Grid00:22:26 Virtualization Techniques in Kendo React00:25:31 Design Considerations for Kendo UI Components00:28:37 Theme Builder: Bridging Design and Development00:38:15 Version Control in Design Workflows00:39:22 The Evolution of Theme Builder00:40:41 User-Centric Design and Feedback00:42:35 The Role of Design Systems00:44:37 Bridging the Gap: Designer-Developer Collaboration00:46:12 Understanding Design Tokens00:47:57 Incremental Adoption of Kendo React00:55:53 State Management in Kendo React00:62:37 Bundle Size Considerations01:10:35 Measuring the Success of a Design System01:15:14 Design Systems and Component Libraries01:19:45 The Role of Progress and Kendo UI01:24:21 Learning Resources for Developers01:27:56 Evaluating UI Component Libraries01:33:56 Collaboration in UI Design and Development01:36:14 Emerging Technologies and AI in UI Development01:44:23 Future Trends in React and UI Components Hosted on Acast. See acast.com/privacy for more information.
    --------  
    1:47:44
  • Event Sourced Architecture: A Deep Dive
    Follow me on 𝕏: https://x.com/tejaskumar_This podcast episode dives deep into the world of Event Sourcing, a powerful architectural pattern used in modern software development. Beginning with a clear definition of Event Sourcing, the episode explores its roots in Domain Driven Design and its critical role in recording and storing every change made to the state of an application in an event store. I break down complex topics, such as the nature of events, the intricacies of implementing Event Sourcing in real-world applications, and the various benefits and challenges associated with this approach.Listeners will gain insights into the practical aspects of Event Sourcing, including detailed discussions on storage costs, computational expenses, and the practice of snapshotting to optimize performance. The episode also covers the concept of event ownership, Command Query Responsibility Segregation (CQRS), and ensuring data consistency using Apache Kafka, a distributed event streaming platform known for its high throughput, reliability, and scalability.Further, the episode delves into Kafka's performance mechanisms, its use as an event store, and the transition from Zookeeper to KRaft for cluster coordination. Alternatives to Kafka, such as using Postgres' Write-Ahead Logging (WAL) as an event store, are examined, providing listeners with a comprehensive view of the options available for implementing Event Sourcing.The discussion extends to real-life use cases of Event Sourcing, highlighting its application across various industries and projects. The experts also tackle some of the common problems encountered when adopting Event Sourcing, offering practical advice and solutions. Finally, the episode concludes with a thoughtful analysis on whether Event Sourcing is the right choice for your project, helping listeners to make informed decisions based on their specific needs and project requirements.This episode is a must-listen for software developers, architects, and technology leaders looking to understand Event Sourcing, its benefits, challenges, and implementation strategies. Whether you're new to Event Sourcing or looking to refine your existing knowledge, this episode provides valuable insights into making the most of this powerful architectural pattern.Chapters00:00 - Intro03:33 - Sponsor (CrabNebula.dev)04:21 - Defining Event Sourcing07:47 - What are Events? (Domain Driven Design)14:45 - Real-World Examples of Event Sourcing19:52 - Complexities of Event Sourcing21:33 - Storage Costs23:36 - Computational Costs24:10 - Snapshotting35:15 - Event Ownership36:19 - CQRS44:08 - Consistency with Kafka54:10 - Kafka Performance Mechanisms01:03:05 - Kafka as an Event Store01:04:13 - Zookeeper & KRaft01:09:47 - Postgres WAL as an Event Store?01:13:24 - Event Sourcing Use Cases01:18:50 - Event Sourcing Problems01:26:22 - Should You Event Source?01:27:44 - Conclusion Hosted on Acast. See acast.com/privacy for more information.
    --------  
    1:29:34

Meer Technologie podcasts

Over ConTejas Code

ConTejas Code is a podcast in the web engineering space that has deep dives on various topics between frontend engineering with React, TypeScript, Next.js, and backend engineering with Kafka, Postgres, and more. The series is a mix of long-form content and guest episodes with industry leaders in the web engineering space.From the podcast, listeners will take away actionable best practices that you can integrate into your workflows as well as valuable insights from prominent people in the industry. Hosted on Acast. See acast.com/privacy for more information.
Podcast website

Luister naar ConTejas Code, Bright Podcast en vele andere podcasts van over de hele wereld met de radio.net-app

Ontvang de gratis radio.net app

  • Zenders en podcasts om te bookmarken
  • Streamen via Wi-Fi of Bluetooth
  • Ondersteunt Carplay & Android Auto
  • Veel andere app-functies
Social
v7.17.1 | © 2007-2025 radio.de GmbH
Generated: 5/9/2025 - 6:04:48 AM