ConTejas Code

Links- CodeCrafters (sponsor): https://tej.as/codecrafters- Frame: https://brilliant.xyz/products/frame- Bobak on X: https://x.com/btavangarSummaryIn this episode, Bobak Tavangar, founder of Brilliant Labs, discusses the creation of the AR device Frame and the open-source assistant Noah. He shares his journey from working at Microsoft and Apple to founding his own AR company, emphasizing innovation, simplicity, and user transformation in AR. He highlights the limitations of relying on large companies and big budgets, and the unique focus of Frame on AI, user experience, security, and privacy. Frame aims to create open, hackable smart glasses, offering distinctive, lightweight designs and future style variations. The glasses integrate with smartphones, and the assistant Noah extends developer capabilities. Tavangar reflects on the lessons from Google Glass, the challenges of hardware creation, and the importance of design and purpose.Takeaways- Innovation in AR comes from taking unique paths.- Noah, an open-source assistant, enables a broader developer ecosystem.- Frame smart glasses focus on user experience, security, and privacy.- Combining openness with quality and curation is key.- Learn from Google Glass's successes and failures.Chapters00:00 - Introduction and Background 10:02 - The Genesis of Brilliant Labs and AR 14:52 - The Missing Ingredient in AR 28:18 - Noah: An Open-Source Assistant for Frame 31:20 - Differentiating Frame from Other AR Devices 35:09 - Creating Open and Hackable Smart Glasses 38:51 - The Third Path: Combining Openness with Quality and Curation 41:41 - Networking Human Experience 45:42 - The Dangers of Subsidizing Product Sales at a Loss 57:31 - The Future of Glasses: Smart and Indispensable 01:01:01 - Designing for Thinness, Weight, and Distinctive Style 01:04:49 - Local Models: Balancing Functionality and Hardware Constraints 01:08:03 - Lessons from Google Glass and the Importance of Purpose and Design 01:12:20 - Advice for Aspiring Hardware Founders 01:21:44 - Specifications of Frame: Battery Life and Charging 01:27:08 - The Only Rules That Matter: God and Physics Hosted on Acast. See acast.com/privacy for more information.

Links- CodeCrafters (Sponsor): https://tej.as/codecrafters- Daniel on X: https://x.com/danieljcafonso- Daniel's comic book talk: https://www.youtube.com/watch?v=TBxipPwGvHY&list=PL6EW34-Kvy8UfigafIhb5l4thKqOvMgIFSummaryDaniel Afonso shares his journey as a developer advocate, emphasizing his passion for educating developers through conference talks and comic books. He discusses using storytelling and entertainment to explain complex technical topics, including fine-grained reactivity with Marvel's Watchers as an analogy. He addresses overcoming imposter syndrome by learning and presenting topics he initially struggles with and offers tips for creating effective Call for Proposals (CFPs). This episode educates listeners on how tech conferences work and how to secure speaking spots, highlighting the importance of passion, authenticity, and personal experiences in talks, the role of storytelling, and the need for diversity and empathy in developer relations. We also discuss the significance of growth and change in professional environments.Takeaways- Embrace opportunities for growth and learning to overcome imposter syndrome.- Use storytelling and entertainment in presentations to make them engaging and memorable.- Passion and authenticity are key in delivering engaging talks.- Diversity in conference talks is important to bring different perspectives and ideas to the audience.- Empathy is crucial in developer relations and understanding the needs and struggles of others.Chapters03:18 Introduction06:22 Imposter Syndrome and Conference Speaking12:14 Using Comic Books to Teach Technical Topics25:17 Explaining Fine-Grained Reactivity with Watchers33:12 The Process of Eliminating Imposter Syndrome35:26 Creating Effective CFPs01:00:43 The Importance of Diversity in Conference Talks01:07:18 Passion and Authenticity in Speaking01:26:23 The Importance of Empathy in Developer Relations01:37:21 The Importance of Recognizing Personal Value Hosted on Acast. See acast.com/privacy for more information.

Links- Codecrafters (sponsor): https://tej.as/codecrafters- Guillermo on 𝕏: https://x.com/rauchg- Vercel: https://vercel.com- Latency Numbers Every Frontend Developer Should Know: https://vercel.com/blog/latency-numbers-every-web-developer-should-know- Latency Numbers Every Programmer Should Know: https://brenocon.com/dean_perf.htmlSummaryIn this discussion with Guillermo Rauch (creator of Socket.io, Next.js, and Vercel CEO), we cover open source, latency, software as physical systems, PPR, distributed systems, edge computing, Vercel’s data centers, AWS/Azure partnerships, reducing cold starts, and balancing quality with rapid shipping.Takeaways- Starting from a solid open-source background.- Understanding latency is crucial for optimizing user experience.- Viewing software as physical systems aids in performance and scalability.- Partial pre-rendering (PPR) improves performance by merging static pre-rendering with dynamic server-side rendering.- Globally distributed systems face challenges like data residency, cost, and compliance.- Edge computing is key to enhancing website performance and user experience.- Vercel uses edge computing for fast data transfer and performance.- Vercel’s infrastructure includes mega data centers and partnerships with AWS and Azure.- Reducing cold start times is a Vercel priority, with significant advancements.- Maintaining high quality and attention to detail is crucial, even with rapid shipping.Chapters03:42 Introduction and Background11:55 Importance of Latency32:24 Challenges of Globally Distributed Systems43:11 Power of Edge Computing53:18 Edge as the Blessed Path Hosted on Acast. See acast.com/privacy for more information.

LinksCodecrafters (Sponsor): https://tej.as/codecraftersStately: https://stately.aiClerk: https://clerk.comJeff on 𝕏: https://x.com/jescalanSummaryIn this episode, Jeff Escalante (Director of Engineering at Clerk.com) discusses his shift from web development to management, emphasizing replacing oneself as an IC, expanding vision, and acting at the promotion level. He covers leveling employees, handling interview ambiguity, prioritizing customer needs, using Clerk’s feedback system, and choosing tools like ProductLane. The talk also highlights evaluating tech skills, being authentic at work, and balancing honesty with team safety.Takeaways1. Promotions and Management: Manage current duties before moving to management; promotions should reflect demonstrated behavior and vision, with clear guidelines and support from companies.2. Handling Ambiguity and Feedback: Address ambiguity in interviews with thoughtful analysis and solutions; prioritize customer feedback and tech debt using centralized systems.3. Choosing Software and Partnerships: Select software based on integration and vendor responsiveness; collaborate with smaller companies for mutual benefits.4. Tech Skills and Authenticity: Evaluate tech skills and adaptability in interviews; be authentic while adapting to work contexts.5. Relationships and Communication: Balance honesty and trust in relationships; respect communication preferences to build genuine connections. Jeff's handbook offers valuable insights for engineering teams.Chapters04:40 Introduction and Background07:52 Starting Out in Web Development13:39 Transitioning to Management at HashiCorp17:42 Working on Websites and Next.js29:49 Promotions and Expanding Field of Vision36:43 Navigating Promotions and Expectations41:16 Dealing with Frustration and Finding New Opportunities41:50 The Importance of Properly Leveling Employees43:21 Strategies for Leveling Employees47:09 Handling Ambiguity in Interviews50:48 The Value of Conversation in Defining Projects53:21 Determining Comfort Levels in Ambiguity53:54 The Vision-Scope Leveling Question58:23 Prioritizing Customer Needs and Tech Debt01:01:02 Navigating the Chaos of Undefined Spaces01:05:55 Listening to Customer Feedback at Clerk01:12:07 Importance of Centralized Feedback System01:12:56 Challenges in Mapping Feedback to Projects01:15:47 Choosing Product Lane over Other Tools01:20:17 Value of Partnerships and Investing in Software01:23:51 The Third Pillar: Evaluating Tech Skills and Handling Ambiguity01:29:55 Honoring Context and Being Your Full Self01:31:43 Navigating Personal and Professional Relationships01:39:02 Balancing Honesty and Building Genuine Relationships01:40:05 Closing Remarks and Handbook Release Hosted on Acast. See acast.com/privacy for more information.

Let's stay in touch? https://twitter.com/tejaskumar_Links- Codecrafters (Sponsor): https://tej.as/codecrafters- Stately.ai (Sponsor): https://stately.ai- Matt on X: https://x.com/biilmann- Netlify: https://netlify.comSummaryIn this podcast episode, Mathias Biilmann, co-founder and CEO of Netlify, discusses the evolution of Netlify and the invention of the term "Jamstack" in the serverless landscape. Throughout this conversation, Biilmann shares essential life lessons for CEOs and aspiring entrepreneurs, delving deep into the engineering challenges and successes of building Netlify.Takeaways- Engineering Innovation: Netlify's journey began with a strong focus on engineering excellence, introducing innovative solutions like deploy previews and immutable deploys. This podcast highlights how Netlify revolutionized the web UI layer, now moving towards exciting uses of AI and open source technologies.- Jamstack and Serverless Architecture: Biilmann discusses the significance of the Jamstack approach and serverless functions in scaling Netlify's architecture. The platform's ability to handle high traffic and resist DDoS attacks is emphasized, showcasing the robustness of its engineering.- CEO Insights and Life Lessons: As CEO, Biilmann reflects on the strategic decisions made during Netlify's growth, from handling large enterprise clients like Unilever to implementing a Netlify-specific CDN. His insights provide valuable life lessons for listeners interested in technology leadership.- AI and Artificial Intelligence: The integration of AI into Netlify's platform is a focal point, with AI features enhancing user experience and operational efficiency. The podcast discusses AI-powered features like deploy diagnostics and AI responses in tools like Slack, which align with the latest trends in artificial intelligence and VR.- Open Source and Community Engagement: Open sourcing parts of Netlify's platform has contributed significantly to its community engagement. This podcast episode explores how open source principles are integral to Netlify's development and how they resonate with broader engineering practices.- The Role of a Founder CEO: Reflecting on the podcast, Matt shares life lessons on the evolving role of a CEO in the tech industry. From coding to strategic decision-making, the responsibilities vary but always aim to add significant value to the business.Chapters05:23 Introduction and Background08:36 The Vision for Netlify11:24 Challenges and Resistance14:15 Self-Belief and Conviction17:08 The Git-Centric Workflow33:24 Scaling to Functions and Custom CDN38:03 Building a Software-Only CDN39:27 Open Sourcing Netlify41:28 Separation of Concerns41:50 The Role of the CEO and Founder44:58 Handling Traffic Spikes and DDoS Attacks54:42 The Importance of a Free Tier56:49 Bottom-Up Approach and Enterprise Selling01:02:54 The Evolution of Revenue Generation01:04:42 The Power of Developer Advocacy01:06:29 Handling Large Enterprise Clients01:07:50 Netlify's Enterprise Customers01:08:37 Improvements to Netlify's Local Development Experience01:09:37 Simplifying Adapters for Frameworks01:10:36 Improving Caching for Dynamic Content01:11:33 New Features for Frameworks on Netlify01:14:27 Simplified Next.js Runtime on Netlify01:16:55 Long-Running Functions and Jobs01:21:44 AI Features and UI 2.001:25:31 Using AI to Improve Netlify's Product01:27:23 Shortening the Time from Code to Production01:32:37 The Role of a Founder CEO Hosted on Acast. See acast.com/privacy for more information.

Don't forget to share and subscribe. Follow along on 𝕏 at https://x.com/tejaskumar_Links- Codecrafters (sponsor): https://tej.as/codecrafters- THAT Conference (partner): https://www.thatconference.com- Artem on 𝕏: https://x.com/kettanaito- Epic Web: https://epicweb.dev- The Golden Rule of Assertions: https://www.epicweb.dev/the-golden-rule-of-assertions- The True Purpose of Testing: https://www.epicweb.dev/the-true-purpose-of-testingTakeaways- Automated testing is crucial for writing better and more reliable software.- Testing helps developers describe the intention behind the code and ensure that the implementation meets that intention.- Starting with a minimal functional prototype and then writing tests to verify its behavior is a practical approach to testing.- Mocking is a technique that helps establish testing boundaries and allows developers to focus on specific behaviors in their tests. Mocking allows you to model different scenarios and create the desired context for tests.- The testing setup phase is crucial and often underappreciated.- The golden rule of assertion states that a test should only fail if the intention behind the system is not met.- Mock Service Worker (MSW) is an API mocking library that uses the Service Worker API to intercept requests and supports both browser and Node.js environments. Open source sustainability is challenging, but financial support from companies can make it more sustainable.- MSW has gained financial support through programs and partnerships, allowing for further development and support for users.- Concurrent testing support in MSW allows for better performance and avoids shared state issues.- Async local storage is a powerful tool in Node.js that helps solve concurrency issues in testing.- Setting limitations and principles for open source projects helps maintain focus and manage the scope.- Saying no to contributions is important to maintain the project's vision and scope.- Adding tests to projects, even small ones, can provide value and ensure reliability.- The future of testing lies in making it more accessible and having a testing strategy in place.- Balancing speed and quality in testing requires finding a minimal viable test suite that provides value.- Automated testing is crucial for ensuring software works reliably in different circumstances.- The future of testing involves making it more accessible and promoting its importance in software development.Chapters08:13 The Importance of Automated Testing15:37 Artem's Role at Epic Web and Testing Workshops27:02 Future Plans for Epic Web and Workshops28:45 Understanding Mocking and Mocking Strategies31:51 Introduction to Mocking and Modeling Scenarios33:43 The Broad Use Case of Mocking35:20 Finding the Right Balance in Mocking36:40 The Golden Rule of Assertion39:19 Creation and Iterative Process of Mock Service Worker (MSW)45:10 Adding Support for Node.js in MSW52:47 Mocking WebSockets with MSW01:04:54 Open Source and Sustainability01:05:43 Supporting MSW01:07:16 Solving Issues with MSW01:08:22 Concurrent Testing Support01:10:38 Using Async Local Storage01:13:30 Strategies for Open Source Maintainers01:14:27 Balancing Work-Life and Open Source01:18:50 Saying No to Contributions01:26:03 Balancing Speed and Quality in Testing01:29:00 Adding Automated Testing to Projects01:33:49 The Future of Testing Hosted on Acast. See acast.com/privacy for more information.

Links:- https://tej.as/codecrafters (sponsor)- https://daily.dev- https://x.com/FrancescoCiull4- https://youtube.com/@francescociullaJoin the conversation on 𝕏 at https://x.com/tejaskumar_In this episode, Francesco Ciulla, a developer and advocate at Daily.dev, shares his journey from working at the European Space Agency to becoming a Docker captain and content creator. He discusses the role of Docker in the tech industry and the process of becoming a Docker captain. Francesco also addresses accusations and criticism he has faced as a content creator and emphasizes the importance of supporting each other on social media. He shares his experience working at the European Space Agency and the use of Docker in managing complex systems. Finally, Francesco talks about his focus on Rust and the benefits of starting a YouTube channel. Francesco Ciulla discusses his journey of learning in private and learning in public, emphasizing the value of documenting the learning process. He shares his motivation for creating content and the benefits of being an early adopter in a less crowded space. Francesco also talks about accepting and embracing introversion, and how it has influenced his teaching and content creation. He highlights the importance of putting pressure on oneself to grow and achieve goals, while maintaining a growth mindset and being brutally honest about one's abilities and aspirations. He emphasizes that it's never too late to pursue your passions and make a change in your career. Francesco also explains the role of a developer advocate and the importance of building trust and connections with developers. He discusses the unique model of daily.dev, a platform for developers, and how it relies on funding and community engagement. Francesco shares insights on measuring the effectiveness of dev rel work and provides tips for leveraging social media algorithms to increase visibility and engagement.Takeaways- It's never too late to pursue your passions and make a change in your career.- Developer advocates play a crucial role in building trust and connections between companies and developers.- The daily.dev platform relies on funding and community engagement to provide free content and services to developers.- Measuring the effectiveness of dev rel work can be challenging, but metrics such as social media growth and user engagement can be used as indicators.- Understanding the algorithms and audience of each social media platform is essential for maximizing visibility and engagement.Chapters01:06 Becoming a Docker Captain14:08 Working at the European Space Agency28:36 Exploring Rust and Content Creation30:03 Learning in Private vs. Learning in Public34:02 Teaching and Documenting the Learning Process41:17 Accepting and Embracing Introversion46:17 Putting Pressure on Yourself to Grow53:51 Growth Mindset01:03:22 It's Never Too Late01:06:06 Understanding DevRel01:11:30 Daily.dev and the Free Model01:18:36 Measuring DevRel Success01:26:00 Algorithm Tricks for Social Media01:33:04 Closing Remarks Hosted on Acast. See acast.com/privacy for more information.

Links- Codecrafters (Sponsor): https://tej.as/codecrafters- Ujjwal on X: https://x.com/ryzokuken- Tejas on X: https://x.com/tejaskumar_Takeaways- TC39 is responsible for maintaining the JavaScript language specification and ensuring the evolution of the language.- Implementing JavaScript in browsers is a collaborative effort between companies like Google, Mozilla, and Apple, with Igalia playing a significant role.- Language evolution requires balancing the needs and perspectives of various stakeholders, including browser vendors, platform owners, and developers.- API design considerations include security, privacy, and the ability to isolate potential risks.- Moving slowly in language development is crucial to ensure stability and safety. The web is both a blessing and a curse, serving as a reliable and trustworthy platform for communication while also presenting challenges like disinformation.- Web technologies have become the de facto way of building interfaces, surpassing other methods and becoming a crucial part of the tech stack.- Internationalization in JavaScript is facilitated by the Intl suite, which provides building blocks for localizing content into different languages, currencies, and cultures.- Participating in the TC39 process involves engaging in discussions and providing feedback on proposals through GitHub repositories.- Respectful and inclusive discussions are essential in the TC39 process, fostering collaboration and ensuring the growth and improvement of the JavaScript language.- Internationalization plays a crucial role in making the web more accessible and inclusive, allowing people from different cultures and geographies to engage with online content. Technology needs to be more inclusive and adaptive to accommodate the needs of all users.- The bias in technology benefits those who are already privileged, and it is important to address this bias to create a more equitable tech ecosystem.- The web should be accessible to all, regardless of language or cultural background.Chapters05:00 Introduction and Background12:49 Implementing JavaScript in Browsers20:01 The Challenges of Language Evolution34:57 Balancing Stakeholder Perspectives in TC3937:45 The Importance of Moving Slowly in Language Development38:21 The Blessing and Curse of the Web45:11 The Journey of Temporal and Intl53:25 Participating in the TC39 Process01:06:38 The Philosophical Question of Accessibility01:09:59 The Need for a Broader Perspective01:11:00 The Bias in Technology01:15:10 The Divide Between English and Non-English Speakers01:19:35 The Challenge of Implementing Different Calendars01:24:28 The Role of AI in the Web01:30:08 Contributing to the TC39 Committee01:38:55 Dreaming Big for the Future Hosted on Acast. See acast.com/privacy for more information.

Links- Codecrafters (Sponsor): https://tej.as/codecrafters- Follow me on X: https://twitter.com/tejaskumar_- Follow Yoav on X: https://twitter.com/HamatoYogi- Qwik’s next leap - moving forward together: https://builder.io/blog/qwik-next-leap- Towards Qwik 2.0: Lighter, Faster, Better: https://builder.io/blog/qwik-2-coming-soon- Qwik Microfrontends TikTok clone: https://github.com/gioboa/qwik-tiktok-microfrontends- Qwik-angular: https://github.com/QwikDev/qwik-angular- Qwik-vue: https://github.com/mizchi/qwik-vue- Visual copilot v1: https://builder.io/blog/visual-copilotTakeaways- Builder.io is a visual headless CMS that allows developers to build websites and sections of websites using a visual editor.- The Builder.io ecosystem includes tools like Party Town and Mitosis, which help with managing third-party scripts and transforming code for different frameworks.- Developers can register their own components from their code base in Builder.io and easily connect them to the visual editor.- Builder.io can be used in collaboration with other CMS platforms and APIs, allowing for flexibility and integration with existing systems. Qwik is becoming an open-source project, detached from Builder.io, to encourage community involvement and contributions.- Qwik is well-positioned to address Core Web Vitals and improve Interaction to Next Paint (INP) scores.- Qwik UI and other ecosystem projects enhance the Qwik framework and provide additional functionality.- Qwik 2.x will introduce improvements such as out-of-order streaming and a better micro-front-end story.- The concept of Qwik Server Components is being explored, but it may not align with the server-first approach of Qwik.- Apple's support for PWAs remains a topic of discussion and debate.SummaryYoav Ganbar, a developer relations engineer at Builder.io, joins the podcast to discuss the visual headless CMS and its ecosystem. Yoav shares his background and how he ended up at Builder.io. He explains that Builder.io is a visual no-code tool that helps build websites and sections of websites, and it is framework-agnostic. Yoav also introduces the other tools in the Builder.io ecosystem, including Party Town and Mitosis. In this part of the conversation, Yoav Ganbar discusses the Visual Copilot V1 and the ecosystem, the use of Mitosis and Sveltosis in Builder.io, the core principles and unique selling points of Qwik, the implementation and debugging of Qwik, the upcoming Qwik 2.0 and community-driven development, the importance of understanding servers in web development, the journey of learning web development, and a big announcement made by Yoav Ganbar. In this conversation, Yoav Ganbar discusses the announcement that Qwik is becoming an open-source project, detached from Builder.io.Chapters03:26 Introduction and Background06:33 Yoav's Journey to Builder11:26 Builder.io and the Ecosystem32:45 Mitosis33:58 Qwik: Core Principles and Unique Selling Points36:16 Qwik Implementation and Debugging39:39 Qwik 2.0 and Community-Driven Development49:14 Builder.io and the Use of Qwik58:20 The Importance of Understanding Servers in Web Development1:01:29 The Journey of Learning Web Development1:02:27 The Big Announcement1:02:36 Qwik Becoming Open Source1:03:35 Qwik and Core Web Vitals1:04:59 Qwik UI and Ecosystem Projects1:05:56 Moving to Qwik Dev and New Governance Model1:06:55 Benefits of Open Source and Community Ownership1:10:27 Improvements in Qwik 2.x1:15:12 Qwik and Core Web Vitals1:17:30 Out of Order Streaming in Qwik 2.x1:24:44 Qwik Server Components1:28:03 Apple and PWAs Hosted on Acast. See acast.com/privacy for more information.

Follow me on 𝕏: https://twitter.com/tejaskumar_Links- Sentry: https://sentry.io- Lazar on 𝕏: https://twitter.com/NikolovLazarIn this in-depth podcast episode, we delve into the world of Sentry, a powerful tool designed to enhance software performance and reliability. From the initial introduction to Sentry's comprehensive suite of features, we explore how Sentry instruments a broad array of software, ensuring peak performance and minimal errors. The discussion includes a comparative analysis with TypeScript, highlighting Sentry's unique approach to software instrumentation and its focus on privacy and security.We further investigate Sentry's capabilities in de-obfuscating code with source maps, offering insights into the nuanced differences between Replay.io, session replay technologies, and Sentry's innovative solutions. The spotlight shines on Sentry's dev-time monitoring, trace propagation within database transactions, and its distinct differentiators that set it apart from competitors. Notably, the episode covers Sentry's report on the most common pitfalls in apps, akin to a Spotify Wrapped but for software errors, providing a deep dive into error and stack proximity reporting with Sentry.Performance metrics, such as the Apdex score and Core Web Vitals, including Cumulative Layout Shift (CLS), are thoroughly examined, alongside strategies for mitigating CLS and addressing font-related issues like Flash of Unstyled Text (FOUT) and Flash of Invisible Text (FOIT). The episode proposes innovative solutions, such as tree shaking for font glyphs and dynamic font replacement to prevent layout shifts and text visibility problems.Listeners will gain insights into Sentry's internals, including its architecture, use of Rust, and data storage strategies. The episode also discusses the scale challenges Sentry has overcome and how Sentry employs its own tools for self-monitoring. The conversation concludes with guidance on when to avoid Sentry and reiterates best practices for utilizing Sentry to its full potential, ensuring listeners are equipped with the knowledge to tackle common software performance issues effectively.Chapters00:00 - Intro01:07 - Sponsor01:51 - Greetings02:53 - Defining Sentry's Suite of Features04:43 - How does Sentry instrument a wide variety of software?09:32 - Sentry compared to TypeScript12:31 - Sentry and Privacy16:57 - De-obfuscating Code with Source Maps19:46 - Replay.io vs. Session Replay and Sentry21:20 - Sentry Spotlight and Dev-Time Monitoring25:07 - Propagating a Trace inside a Database Transaction27:38 - Sentry Differentiators35:58 - Sentry Report of Most Common Pitfalls in Apps, like Spotify Wrapped but with Sentry39:42 - Children and error/stack proximity with Sentry reporting42:22 - The Apdex as a Performance Metric44:56 - Performance and Core Web Vitals49:20 - Cumulative Layout Shift (CLS)54:43 - Where does CLS happen in the rendering process and mitigation steps58:19 - Fonts as a source of CLS, FOUT (Flash of Unstyled Text), and FOIT (Flash of Invisible Text)01:05:11 - Free Open Source Project Idea: Tree Shaking for Font Glyphs01:05:57 - Replacing fonts when loaded to prevent CLS, FOIT, and FOUT01:08:51 - How Sentry helps with Core Web Vitals01:11:49 - Sentry Internals: Architecture, Data Stores, Rust01:17:21 - Scale Problems that Sentry went through01:19:12 - Does Sentry use Sentry? Sentry on Sentry01:21:13 - When to Avoid Sentry01:22:11 - Sentry Salient (Repeating) Best Practices01:26:10 - Conclusion Hosted on Acast. See acast.com/privacy for more information.

Follow me on 𝕏 for more: https://twitter.com/tejaskumar_Links- Kyle on 𝕏: https://twitter.com/getifyx- Vella.ai: https://vella.ai- Codecrafters (sponsor): https://tej.as/codecrafters- Stately (sponsor): https://stately.aiTakeaways- The You Don't Know JS books have been successful, with over 300,000 copies sold across all editions.- Kyle Simpson decided to move away from the traditional publishing model due to constraints and a desire for more creative freedom.- Giving away the books for free on GitHub has not negatively impacted sales, and many readers have chosen to support Kyle by purchasing the books.- Accessibility and making knowledge available to a wide audience are central to Kyle's approach.- There are multiple pathways to publishing, including traditional publishing, self-publishing, and platforms like Leanpub. Publishing with O'Reilly provides a prestigious reputation and distribution, while self-publishing offers more control and potentially higher royalties.- Get a Pub is Kyle's publishing assistance service for self-published authors, while Lean Pub is a platform for incremental publishing and distribution.- Education should be seen as an ongoing journey, and college degrees may become less relevant over time as the industry evolves.- Gatekeeping in the tech industry can be a barrier for those without formal education, but continuous learning and self-education can bridge the gap.- Rejection can be a catalyst for personal growth and the pursuit of knowledge, leading to impactful contributions and a deeper understanding of a subject.- Prioritizing knowledge and learning in the workplace is essential for personal and professional growth, and it's important to find a company that values continuous learning.- Learning should be seen as a continuous process, with a focus on understanding and deepening knowledge rather than just acquiring new skills.- Vella.ai is a venture that aims to prioritize user ownership of data and privacy, offering a local-first approach to AI and smart assistants.In this episode, Kyle Simpson discusses his experience as the author of the You Don't Know JS books and his decision to move away from the traditional publishing model. He shares the status and future plans of the second edition of the books and the impact of giving away the content for free on GitHub. Kyle emphasizes the importance of accessibility and making knowledge available to as many people as possible. Chapters- 04:59 Introduction and Background- 05:59 You Don't Know JS Books- 09:19 Status and Future Plans of the Second Edition- 10:13 Published Books in the Second Edition- 11:40 Books That May Not Be Written- 13:44 Authoring Experience and Constraints- 18:20 Giving Away the Book for Free on GitHub- 29:26 Accessibility and Publishing Dreams- 31:01 Pathways to Publishing- 39:44 Publishing with O'Reilly and Self-Publishing- 41:02 Get a Pub and Lean Pub- 47:46 Education, Gatekeeping, and Learning- 50:35 The Role of College and Continuous Learning- 58:43 Kyle's Rejection from Twitter and the You Don't Know JS Series- 01:11:45 Prioritizing Knowledge and Learning in the Workplace- 01:12:15 Becoming Less Employable and Unexpected Challenges- 01:13:57 The Misunderstanding of Tejas' Contract- 01:15:12 The Value of Specialization and Experience- 01:17:54 Learning as a Living Standard- 01:22:14 The Shift in Valuing Experience in Engineering- 01:25:16 The Dog Wagging the Tail in Tech- 01:28:00 Kyle's Venture: Vela.ai- 01:35:45 The Mission of Vela.ai Hosted on Acast. See acast.com/privacy for more information.

Follow us on 𝕏: https://twitter.com/tejaskumar_Dive into the cutting-edge of web development with our latest episode, focusing on SolidJS, React fatigue, and innovative JavaScript technologies. We kick off with an inspirational look at SolidJS, exploring why developers are shifting towards this reactive framework amidst growing React skepticism. Delve into the TC39 proposal for native JavaScript Signals and the burgeoning SolidStart ecosystem, underlining its appeal through ease of contribution compared to React.We unpack SolidJS documentation and Atila's journey into the project, highlighting the framework's accessibility for newcomers and contrasting it with React's complexity. The discussion extends to implementing Signals in React, evaluating the tangible benefits of performance optimizations, and detailing SolidJS's advantages and potential drawbacks.Stay tuned for insights into SolidStart's latest developments, the vibrant SolidJS community, and practical advice for migrating from other libraries. Special segments include a spotlight on codemods, the groundbreaking CrabNebula project, and leveraging Tauri with Rust for desktop applications. We explore Rust's benefits, the unique offerings of CrabNebula in DevTools, cloud solutions, and security audits, culminating with ways to engage with CrabNebula's initiatives.Wrapping up, Atila shares key takeaways on navigating the evolving web development landscape. Whether you're contending with React fatigue, curious about SolidJS, or interested in desktop app development with Tauri and Rust, this episode offers invaluable insights into modern web technologies and their practical applications.Links:- Atila on 𝕏: https://twitter.com/atilafassina- Atila on YouTube:  @AtilaDotIO  - SolidJS: https://solidjs.com- CrabNebula: https://crabnebula.dev- Tauri DevTools: https://devtools.crabnebula.dev- Tauri: https://tauri.appChapters00:00 - Intro02:59 - Welcome04:20 - Getting Inspired about SolidJS06:59 - React Fatigue: Doubts and Questions about React10:09 - Signals as Native JavaScript (TC39 Proposal)12:38 - SolidStart and Ecosystem21:01 - SolidJS Docs and How Atila Got Involved24:45 - React is Hard to Contribute To/SolidJS is Easier; Why?35:23 - Understanding SolidJS for newcomers40:33 - Signals in React46:38 - Do the minimal perf gains even matter?52:56 - SolidJS Pros and Cons56:45 - SolidStart Developments01:04:27 - SolidJS Community and Ryan01:07:39 - Migrating to SolidJS from another library01:12:28 - Codemods and Kent C. Dodds01:14:15 - CrabNebula01:15:57 - Tauri, Rust, and Desktop Apps with JavaScript01:21:13 - Rust: Benefits and Tradeoffs01:32:37 - CrabNebula offerings: DevTools for Tauri01:41:00 - CrabNebula offerings: Cloud01:42:17 - CrabNebula offerings: Security Audits01:44:46 - Getting involved with CrabNebula01:45:57 - Main Takeaway from Atila01:47:01 - Conclusion Hosted on Acast. See acast.com/privacy for more information.

Follow me on 𝕏: https://x.com/tejaskumar_Dive into the fascinating world of computing with our podcast episode titled "How do computers actually work? From electrons to hardware to the web." We unravel the mystery starting from the fundamental building blocks of technology—electrons, and how they power datacenters, to the intricacies of hardware and firmware. Journey through the critical layers of computing, including the OS kernel, CPU operations, memory management, and storage solutions. Security gets its due with an exploration of TPM, setting the stage for a deep dive into software architecture. We break down frontend technologies and backend infrastructure, covering everything from HTML and CSS to cloud computing and network protocols. The episode culminates with a discussion on CI/CD pipelines and the decision-making process in tech development. It's a comprehensive guide for anyone curious about the inner workings of computers and the internet.Chapters00:00 - Intro01:17 - Sponsor02:47 - Everything is a Stack, with Layers on Layers04:55 - The Lowest Layer: Subatomic Particles09:21 - Types of Current: AC and DC (Alternating and Direct Current)12:36 - How Datacenters use Electricity15:45 - The Next Layer: Hardware19:07 - The Next Layer: Firmware21:46 - The Next Layer: The OS Kernel24:21 - Diving Deeper: Motherboard27:59 - The OS Kernel29:43 - CPU, Threading, Multithreading, Hyperthreading, Clock Speed36:53 - Memory/RAM, Volatile Memory, Virtual Memory39:43 - Storage, Hard Drives, Solid State Drives41:33 - TPM (Trusted Platform Module)42:59 - The Next Layer: Software43:46 - Software Architecture47:08 - Frontend Deep Dive: HTML, HTMX, CSS, TailwindCSS, JavaScript, Accessibility, and Network59:53 - What happens when data fetching: TCP/IP stack, HTTP and SSL encryption, how data flows over the network and internet01:12:05 - Receiving a Network Request on the Backend, DNS, Firewalls, Load Balancing, SSL Termination, Reverse Proxies01:20:38 - Backend Architecture: Caches, Queues, Distributed Systems, Control Plane vs. Data Plane01:25:44 - Cloud Computing: Virtual Private Clouds (VPCs), Subnets, NATs01:28:30 - Adjusting Expectations for Frontend and Backend01:29:34 - CI/CD Pipelines, Webhooks, git-based deploys01:30:21 - Build it or buy it?01:31:18 - Conclusion Hosted on Acast. See acast.com/privacy for more information.

Follow us on 𝕏: https://twitter.com/tejaskumar_Links- Sentry: https://sentry.io- Epic Web: https://epicweb.dev- Kent's Website: https://kentcdodds.com- Remix: https://remix.runJoin us in this enlightening episode as we welcome Kent C. Dodds, a renowned figure in the web development community and a dear friend, known for his impactful contributions and innovative teaching methods. Dive deep into Kent's journey, from his initial steps in the tech world to becoming a pivotal voice in modern web development. Explore the evolution of the web, understanding the critical milestones and breaking changes that have shaped its current state. Discover the art of building modern web experiences that surpass user expectations, emphasizing the importance of web performance, and adopting an empathy-driven approach to software development.Kent shares his insights on why Remix stands out as a premier framework, addressing common challenges like the complexity of Next.js and the intricacies of nested routes. Gain valuable knowledge on making strategic decisions between client and server rendering in Remix, and the practical steps for migrating from Vite/SPA to React Server Components (RSCs) with Remix, highlighting the revolutionary potential of RSCs in enhancing web development.The conversation takes a personal turn as Kent discusses his experiences creating the wildly successful Epic React course, revealing his approach to course ideation, preparation, and the secret to staying organized amidst a busy schedule. Listen to inspiring stories from Kent's career at PayPal, his influence on his team, and the personal philosophies that contribute to his enduring happiness and success.Lastly, tackle the daunting task of dealing with legacy code with minimal coverage, offering strategies and insights to navigate and improve upon existing codebases efficiently.This episode is a treasure trove for developers, educators, and tech enthusiasts alike, filled with practical advice, inspiring stories, and a deep dive into the technologies and methodologies driving forward-thinking web development.Chapters00:00 - Intro01:35 - Sponsor02:58 - Greetings03:49 - Kent's Background and Experience05:53 - How did the Web get to where it is today?12:56 - Breaking Changes on the Web20:30 - Building Modern Web Experiences to Meet User Expectations24:07 - Web performance, spinners and loading state: building for users over developers33:03 - Empathy Driven Development; Software as an act of Service38:37 - Why is Remix the best?50:04 - "Next.js was too complex" explained56:00 - Nested Routes in Detail01:07:23 - Lever: Choosing between Client or Server rendering in Remix01:10:30 - Incrementally Migrating from Vite/SPA to React Server Components (RSCs) with Remix01:14:12 - React Server Components (RSCs) in Remix01:25:19 - Server Components and Composability; Kent's new talk on RSCs01:30:50 - Matt Pocock: how was Epic React an overnight success?01:34:29 - Hayat Rachi: How do you go through course ideation and prep?01:36:08 - Artem Zakharchenko: how are you so organized?01:39:13 - David Sancho: PayPal career, team influence, and why Kent seems happy all the time01:42:05 - Oluwatobiloba: how do you deal with a legacy code with minimal coverage?01:44:39 - Conclusion Hosted on Acast. See acast.com/privacy for more information.

Follow us on 𝕏: https://twitter.com/tejaskumar_In today's episode, we dive deep into the world of artificial intelligence, starting with a basic understanding of AI and the pivotal role of AI Engineers. We explore the pressing question: "Is AI going to take my job?" and differentiate between answer engines and search engines, highlighting their impacts on how we find information.Transitioning into web development, our discussion shifts towards CSS, covering advanced topics like view transitions, container queries, the :has selector, dynamic viewport units, and the debate on the necessity of JavaScript (JS) when CSS can offer powerful solutions.Further, we delve into the latest JavaScript updates, including the introduction of `Object.groupBy`, immutable array methods, and exciting new tools and frameworks like vlt (new npm), Bun, Tauri 2.0, and a discussion on modern JavaScript frameworks including Signals, Qwik, and React Forget, focusing on bundle size optimization.We also cover significant HTML developments, such as OpenUI, the new `selectmenu` and `popover` elements, the `dialog` element, and HTMX, offering insights into how these advancements are shaping the future of web development.Wrapping up, we conclude with reflections on the topics covered and their implications for developers and the broader tech community. Join us for an informative journey through the latest in AI and web development.LinksOramaSearch: https://oramasearch.comKarpathy's post: https://twitter.com/karpathy/status/1674873002314563584Rise of the AI Engineer: https://www.latent.space/p/ai-engineerPerplexity (Answer Engine): https://perplexity.aiKeel: https://keel.soKeelGPT: https://chat.openai.com/g/g-0xwNB1Azt-keelgptvlt: https://vlt.shBun: https://bun.shTauri: https://tauri.appOpenUI: https://open-ui.org/HTMX: https://htmx.org/Chapters00:00 - Intro01:53 - Sponsor02:43 - AI05:27 - AI Engineering: What is an AI Engineer?12:26 - Is AI going to take my job?22:53 - Answer Engines vs. Search Engines28:26 - CSS: View Transitions35:45 - CSS: Container Queries48:53 - CSS: :has selector50:41 - CSS: Dynamic Viewport Units54:22 - CSS: Why not just use JS?56:27 - JavaScript: Object.groupBy58:47 - JavaScript: Immutable Array Methods01:04:31 - JavaScript: vlt (new npm)01:08:09 - JavaScript: Bun01:10:47 - JavaScript: Tauri 2.001:15:26 - JavaScript: Frameworks, Signals, Qwik, Bundle Size, React Forget01:31:00 - HTML: OpenUI, selectmenu, popover01:34:20 - HTML: dialog element01:37:05 - HTML: HTMX01:45:31 - Conclusion Hosted on Acast. See acast.com/privacy for more information.

Follow us on 𝕏: https://x.com/tejaskumar_This episode is an introduction to the Contagious Code podcast, outlining the motivation behind the show, what listeners and viewers can expect, and how they can get involved. Episodes will air weekly for a season, where there are about 8 episodes total. Then, we will regroup and record another season that will air after a short break. Ideally, we keep episodes rolling, but we'll need to evaluate this in light of temporal and financial budgets.Chapters:00:00 Intro00:40 Motivation01:37 Podcast Format02:30 Motivation Part 203:57 How to Get Involved05:14 Sponsorships06:07 Conclusion Hosted on Acast. See acast.com/privacy for more information.