Mandy Hartman shared insights on how to get the most out of web development learning. Drawing from her own experiences transitioning into the field, Hartman presented key strategies for new learners.

Mandy highlighted the importance of structuring learning by consistently dedicating specific daily blocks for acquiring new skills or understanding new topics. She endorsed the power of community, encouraging learners to find support and motivation in groups like workshop-specific Discord channels or Slack groups.

Additionally, Hartman highlighted the importance of building a portfolio through side projects to showcase skills to potential employers, and stressed on the importance of leveraging support networks, including friends, family, and mentors.

Hartman's talk was an inspiring and practical guide for those embarking on their web development learning journeys, emphasizing structured learning, community support, practical application, and portfolio building.

Learn web development effectively with Mandy Hartman's expert tips. Discover structured routines and community support for success!








Epic Web Conference 2024

Getting The Most Out of Your Learning Investment

Alex Anderson provides a thorough examination of "local-first" computing, tracing its origins from the early days of mainframe and client-server models to present-day mobile apps and edge computing. He emphasize how the trend towards thicker clients and localized tasks is affecting web development.

Local-first computing has seven ideals that it lives by that Alex dives into in this talk:

Easier ideals: 
- No spinners
- Data not trapped on one device
- Network is optional
- Seemless collaboration with your colleagues

Harder ideals:
- The long now
- Security and privacy by default
- The user retains ultimate ownership and control

Discussing the principles involved and their development implications, Alex considers the challenges of data synchronization, the necessity of offline functionality, and the complexities of multi-user scenarios. He also introduce resources for local-first software development, such as AutoMerge, Yjs, and localfirstweb.dev.

Alex uses a recipe app to demonstrate how local-first computing can be effectively implemented. He highlight the use of RepliCache, a client-side sync framework, and discuss strategies to improve web app performance using Remix. 

The talk concludes by exploring how web apps have serious limitations, even when implemented as Progressive Web Apps (PWAs), when examined under the lense of the local-first ideals. Web apps particularly struggle to uphold the last 3 ideals as data on the web is not permanent and hard to properly secure. Alex remains optimistic about the future of local-first computing in web development seeing them as levers to pull when needed, encouraging developers to explore these techniques to enhance user experience and data control.

Alex Anderson explores "local-first" computing's impact on web development, advocating for its future with tools like AutoMerge and RepliCache.

The Recipe for Local-First

Jacob Parris explores the intricacies of building and maintaining high-performance web applications at scale. He delves into the technical considerations that come into play when choosing the right architecture for an application, emphasizing the importance of stability before speed.

Jacob discusses the merits of server-side rendering (SSR) for providing user-customized content, highlighting it as an effective method to prevent layout shift from asynchronous asset loading. He underscores that optimizing the user experience is key when deciding the architecture of an application.

The talk also covers advanced data management strategies, such as local-first synchronization, as a way to manage local and remote data. Jacob introduces RepliCache as a promising tool to manage local data synchronization.

The presentation delves into the world of CRUD operations and User Experience, with a specific focus on the use of client cache loader. Jacob explains how layering improvements to the app—starting with reliable server loaders—can enhance performance.

Furthermore, he discusses the Remix progressive web app (PWA) package, endorsing the strategy of building a strong foundation using server loaders and then progressively enhancing apps' features.

Jacob Parris guides high-performance web apps, prioritizing stability over speed with SSR, data sync, and progressive enhancement for UX.

High-Performance CRUD Apps

Lina Mahrouch provided an in-depth analysis of Remix's capabilities in her presentation. 

Remix stands out for its commitment to web standards and its ability to provide an amazing developer experience through its 'loaders' and 'actions' features. These features simplify data fetching and backend communication, promoting seamless data flow and efficient feature management in web applications.

Adding flexibility to the framework, Remix incorporates both file-based and config-based routing. Its recent transition to a Vite plugin has enhanced its capabilities, allowing for better integrations and improvements for developers. The framework's application is not confined to eCommerce. It's also used in AI tools, search engines, and portfolio sites, demonstrating its broad utility.

Lina Mahrouch highlights Remix framework's strengths, adherence to standards, simplified data flow, and diverse application beyond eCommerce.

Things You Probably Didn't Know About Remix

Tyler Benfield focused on the importance of optimizing database performance to improve the overall functioning of applications. It was highlighted that an application's speed is often dictated by its slowest database query. Therefore, optimization efforts should prioritize improving database performance.

Tyler demonstrated the significant potential of database performance enhancement, mainly through the use of indexes. Indexes were compared to an alphabetically organized address book, speeding up data retrieval from unindexed tables. He emphasized the need to consider multiple columns within a single index to optimize queries effectively.

Other database performance factors considered were network latency, open database connections, and the use of caching for inherently slow queries. Tyler recommended the use of connection poolers and stressed the importance of the database and application's proximity to minimize latency.

Tyler emphasized continuous monitoring and tracking of database query performance trends, recommending indexing all frequently used queries and foreign keys for immediate improvements.

Optimizing database performance as crucial for application speed, focusing on indexes, minimizing network latency, and monitoring query trends.

Epic App Performance Starts With the Database

In this talk, Scott Hanselman demystifies myths surrounding AI and explains its working principles. He addresses the need for context in AI responses and highlights how AI predictive abilities hinge upon human input for training.

A key aspect of the talk revolves around the ethical implications of AI. Scott emphasizes human responsibility in steering AI towards morally sound outcomes and stresses the importance of setting clear boundaries.

Concluding with an emphasis on careful model integration to avoid misuse, Scott underlines the significance of privacy and community engagement in achieving a better understanding and more efficacious application of AI technologies.

Scott Hanselman demystifies AI, emphasizing human input and ethics, discussing GitHub Copilot and responsible integration.

AI - "Iron Man or Ultron"

Michael Chan shares his expertise on modern practices in component building and testing. This talk primarily revolved around the utility and alternatives to Storybook, a popular tool for developers building component libraries.

The importance of evaluating different testing tools to find what caters to one's specific needs was also underscored. Preference was expressed for the React testing library, due to its focus on accessibility, with other tools like Chromatic and Storybook also receiving commendation.

However, certain limitations of Storybook were pointed out, suggesting it might not serve all React developers equally. As an alternative, the 'Component Story Format' at the core of Storybook was explored, with a tic-tac-toe tutorial in React used to demonstrate its capabilities.

The conversation concluded with the optimism for a future of simpler, less tool-reliant component testing.

Chan explores component building and testing, React Testing Library over Storybook. Limitations, alternatives, and future trends in component testing.

Snapshot-driven Development Capture Visual Tests in Flow

Saron Yitbarek shares insights on the importance of 'learning in public', testing business ideas and the rise of newsletters in the web development industry. She discusses her entrepreneurial journey, including the product validation phase, fundraising, struggles with product engagement, and eventual pivot to newsletter development.

Saron illustrates the importance of audience ownership and direct idea sharing through newsletters. Starting under a company research project with her newsletter "Not a Designer", Saron managed to reach 1,000 subscribers in a month. This success, she state, showed the importance of not just achieving milestones, but enjoying the creation process itself.

Saron emphasizes that 'learning in public' with both successes and failures of the creative process can cultivate career resilience and valuable connections. Starting a newsletter or creating content on social media platforms could ultimately help improve skills, build networks and buffer against the uncertainties of the world.

In the ever-evolving web development industry, Saron recommends embracing public learning as a way to navigate changes, prepare for shifting landscapes, and shield careers from uncertainties.

Saron Yitbarek promotes 'learning in public' through newsletters, stressing its value for career resilience and networking in web development.

Not a Designer

Artem Zakharchenko introduces Mock Service Worker (MSW) API support for WebSockets. A detailed discussion about the use and benefits of a mock environment in the initial stage of development was discussed, with Artem emphasizing the enhanced control it offers over WebSocket events.

The concept of mock-first development was introduced as a way of allowing developers to start work in an environment where the server has not yet been established, with the assistance of MSW. This approach was further unpacked, exploring how it could provide significant benefits when dealing with WebSocket events, which cannot be intercepted using Service Worker API.

Artem demonstrated how to use MSW to develop a WebSocket application. The demonstration involved real-time user interface interactions and event handling. In transitioning from mock to full pass-through mode, MSW can simulate a duplex connection similar to normal WebSockets.

A feature of MSW that was highlighted is its ability to observe and modify server interactions. Through setting up a message listener, a developer can manipulate values coming from the server as well as the client. Artem further noted that MSW is the first API mocking library in the JavaScript ecosystem to support both HTTP and WebSocket protocols.

The talk concluded with an invitation for audience engagement and contribution, encouraging developers to use the pre-release version of MSW and provide feedback.

Artem Zakharchenko presents MSW's WebSocket support, enabling mock-first development for better control and real-time testing.

Mocking WebSockets with MSW

Glauber Costa, the founder of Turso, challenges the usual narrative surrounding SQLite by discussing its potential use for production applications. By addressing SQLite's significant technical capabilities, Glauber uses this talk to dispel the common misconceptions regarding its limitations.

Glauber dives into the following misconceptions and shows you how they might not be the limitation you though:

- Maximum database size
- Read/Write performance
- SQLite back-up strategies
- Horizontal scaling

In conclusion, Glauber encourages developers to consider SQLite for production applications and to explore further resources available on Turso's [GitHub page](https://github.com/tursodatabase).

Glauber Costa challenges SQLite misconceptions for production apps, citing its capabilities and real-world performance, offering tools like Turso for support.

Seriously SQLite

Ryan Florence delves into the evolution of JavaScript, with a particular focus on the ES6 feature `const`. The discussion dives into the `let` and `const` keywords, elements that have had a transformative impact on JavaScript practices, but also stirred noteworthy debates within the coding community.

Misunderstandings around the `const` keyword were addressed, with emphasis on its role as a constant and not a variable. Moreover, Ryan clarified that using `const` does not inherently prevent content mutation. The complexities involved in achieving immutability in JavaScript were also discussed.

The talk underscores the influence of entities such as Udacity and Airbnb on JavaScript coding conventions, stirring a dialogue about the enforcement of coding standards that are not always consistently applied.

In examining the implications of ES6 features, Ryan suggested that strict adherence to rules around variable declaration may not significantly enhance code quality.

In an unexpected twist, the session also ventured into the phonetics of language, specifically the pronunciation of JavaScript keywords and how hard the word `const` is to say.

The talk concluded with a challenge to the audience to broaden their understanding of JavaScript's language features and their applications, highlighting the urgency to focus on user experience over strict coding regulations.

Ryan Florence delves into ES6 evolution, highlighting let and const, immutability complexities, and coding conventions' influence in JavaScript.

Let me be

Dan Farrelly talk focuses on strategies for improving API performance and reliability using events and background functions. Dan emphasizes the need for efficient and optimal user experience, highlighting how complex operations and the evolution of API endpoints can cause bloated code, slow application performance, and potential reliability issues.

These potential pitfalls, such as multiple failure points in processes dependent on third-party APIs, can be mitigated by offloading non-critical logic from the API's critical path and moving to asynchronous operations. The implementation of tools like queues facilitates the management of these background jobs and ensures their reliable execution.

Dan also advocates for robust recovery plans, logging for debugging, and the adoption of event-driven architecture for APIs. The latter provides several benefits such as improved decoupling, scalability, and more efficient API designs. This approach supports parallel execution of independent functionalities and facilitates better recovery, debugging, and analysis.

Finally, Dan emphasizes the importance of creating APIs that are fast, reliable, and user-friendly, while also ensuring that extra processing doesn't affect the API's performance or the user's experience.

Dan Farrelly: Optimize API performance—prioritize critical tasks, leverage queues, plan for recovery, and embrace event-driven architecture.








Improve performance and reliability of your API with events and background functions

Hosts Andrew and Justin are joined by Microsoft's VP of Developer Community, Scott Hanselman, "Chantastic" Michael Chan, former Chromatic developer and incoming WorkOS team member, and Yuna from Google's Chrome team.

The panel focused on the key roles and functions of Developer Relations (DevRel), emphasizing its significance as the bridge between product developers and the user community. The panelists highlighted the importance of empathy and efficient communication in DevRel, and described this role as the backbone of the product development process.

The discussion also touched on the concept of "level privilege," which refers to the ability of senior engineers to freely voice their opinions. A crucial point that emerged from this is the importance of clearly defining and understanding the roles and objectives of a DevRel position.

The conversation then shifted towards the transformative potential of Artificial Intelligence (AI) in web development and developer education. Panelists predicted a shift in learning methodologies brought about by AI and explored various applications of AI, including debugging code and prototyping user interfaces. However, concerns were also raised regarding AI's ethical implications in academic settings and its environmental impact.

The discussion concluded with reflections on the democratization of creativity enabled by AI and the role of inherent difficulties in the creative field. Overall, the panelists provided an insightful discussion on the evolving dynamics of developer relations and the future of AI in web development.

DevTools FM podcast DevRel's empathy, AI's web dev impact, ethical concerns, creativity democratization reflections.

DevTools.fm Live Recording

This insightful lightning talk from Adam Argyle delves into CSS custom properties in modern web development. The central theme of the discussion revolves around the use of these properties - or "variables in a bottle" - for developing dynamic themes and enhancing type-safety.

Adam discusses the creation of a comprehensive theming system based on a single color, with derived properties modifying this base color for a consistent and easily adaptable theme across applications. Crucially, features like dark mode implementation become much easier with CSS custom properties.

One of the highlighted challenges is the loosely typed nature of custom CSS properties, which can lead to systemic issues in development. Adam proposes the use of type-checking tools (TypeScript) coupled with the CSS `@property` feature, to create typed custom properties and avoid these pitfalls.

On the topic of embracing progressive enhancement, the session highlights the successful adoption of `@property` by browsers like Chrome and Safari. One practical application discussed is its use for type guarding in Tailwind 4.

The discussion culminated with a look into the future of CSS custom properties, with Adam speculating on new functionalities and inviting conversation about upcoming specifications for typed CSS variables. Adam emphasizes the power of CSS and encourages developers to harness its full capabilities, such as mathematical functions and scroll-driven animations, for enhanced web development.

Adam Argyle's lightning talk: CSS custom properties for dynamic themes, type-safety. Advocates typed custom properties, explores future features.








Lightning in a bottle with CSS custom properties

Sandrina Pereira focused on the importance of web accessibility, stressing the need for empathy when considering the diverse ways users interact with digital content. This talk highlighted the Web Content Accessibility Guidelines (WCAG), simplified into four principles, and touched upon various compliance tools available to developers.

Sandrina pointed out the limitations of automated accessibility evaluation tools, noting their effectiveness decreases as the interactivity of a website increases. The importance of manual testing, such as keyboard navigation, was underlined to ensure a comprehensive understanding of accessibility.

Techniques for implementing accessibility enhancements and improving navigation were outlined, with the use of Accessible Rich Internet Applications (ARIA) attributes and CSS techniques being described. Sandrina also addressed accessibility challenges in highly animated websites, proposing solutions to improve user interactions.

Accessible interactions were emphasized as being more than just about meeting technical standards; they require an empathetic understanding of the diverse ways users engage with content.

Sandrina Pereira stresses web accessibility, advocating empathy, manual testing, and ARIA attributes for improved interaction.

Accessible interactions in JavaScript apps

Simon Vrachliotis gives a talk showing how, with the use of TailwindCSS, the designer-developer hand-off can be a resiliant part of your teams workflow. Simon discussed the traditional challenges faced during the design handover process and how TailwindCSS can address these issues, making it easier for both sides to work effectively towards a common goal.

The importance of adopting prototyping early in the design process was stressed, alongside the value of designers learning front-end tasks. TailwindCSS was shown to offer the quickest feedback loop from idea to live CSS in the browser, making it a powerful tool for rapid design changes and prototyping.

Simon celebrated TailwindCSS for its ability to bridge the gap between design and development, fostering a more inclusive and efficient working environment. By augmenting the design process and enhancing communication between team members, TailwindCSS was acknowledged as an invaluable asset in the modern web development toolkit.

Simon Vrachliotis highlights TailwindCSS for seamless designer-developer collaboration, emphasizing rapid prototyping and efficient communication.

Unleashing Designers with Tailwind CSS

Michelle Bakels has had experiences of stress and burnout in the tech industry. In this talk, Michelle uses those experiences to emphasize the importance of understanding and addressing health issues in tech-related fields. Stress, overworking, and burnout are common problems among developers, with an alarming 83% having experienced work-related burnout.

Michelle, alongside Gabe Greenberg at G2I, introduced the Developer Health Program, which aims to raise awareness and provide resources on prevalent health issues within the industry. The talk identified chronic stress leading to burnout as a significant concern and explored the negative impacts of an adrenalized work environment and workaholism on physical and mental health.

Contrary to the common belief that success in tech requires overworking, Michelle argued for the importance of rest, leisure, and effective time management. They recommended an Essentialism Plan to focus on high-priority tasks, promote clarity in planning, and prevent burnout. The talk concluded by emphasizing the significance of self-care, healthy sleep patterns, and mental well-being in the tech industry.

Michelle Bakels discusses tech industry burnout, introducing the Developer Health Program with Gabe Greenberg to advocate awareness and self-care.

Tech Broke My Heart

Una Kravets talk explored the newest evolution of CSS and HTML, specifically focusing on scroll animations, accessibility, and UI positioning. CSS continues to become more powerful, allowing for a clear separation of styling and content, as well as minimizing third-party dependencies. A significant portion of the talk revolved around enhancing user experience through scroll-driven animations. New techniques for creating user-responsive animations were introduced, including how to create a scroll timeline that interacts with the scrolling viewport.

To ensure a seamless user experience regardless of browser support, progressive enhancement was stressed. An example of this is to use CSS's '@supports' rule to check for feature compatibility. Una provided advanced CSS techniques for dynamic styling based on scroll position and overflow detection.

The topic then shifted to UI components, with a highlight on the Popover API. Techniques for animating popovers and compensating for lack of broad browser support were covered. This led to a discussion on positioning elements using anchors and the 'position: try' CSS property.

Finally, Una underscored the importance of attributing semantics to popovers to enhance web accessibility, including working closely with accessibility experts. The session concluded with encouragement for developers to continue exploring these new features of CSS and HTML.

Una Kravets explores CSS evolution, emphasizing scroll animations, accessibility, UI positioning, and progressive enhancement for better user experiences.

Less Cruft, More Power: Leverage the Power of the Web Platform

Zeno Rocha explores the emerging trend of developer-first products, noting the increased influence of developers in tech adoption within companies. Zeno traced the evolution of tools through 4 distinct generations created for developers, starting with early offerings like Splunk and JetBrains, evolving to API-centric tools like Auth0 and Firebase, and culminating in current tools like Gatsby and Netlify that emphasize immediate production integration.

The rest of the talk answers the question 'How to create developer happiness?'

The answer comes in the form of 5 categories:
- Cognitive Overload
- The Little Things
- Buyer vs User Dilemma 
- Treat Docs as Code
- Developer Obsessed

Emphasizing the importance of developer happiness, Zeno discussed the detrimental effects of overwhelming choices, drawing from Hick's Law, which states that decision time increases with the number of alternatives. Zeno stressed how attention to detail in developer tools enhances user experience, noting how this care reflects technical competence and excellence.

The talk highlighted the contrast between buyer and user experiences, pointing out the pitfalls of focusing solely on either. Zeno introduced the static usability effect, suggesting tools with visually appealing designs are often perceived as more user-friendly.

Drawing parallels with Maslow's hierarchy of needs, Zeno proposed a similar hierarchy for developers interacting with technology products, emphasizing that tools should not just be functional but also delight users. The presentation ended with a call for continuous improvement and innovation in the tech and programming space.

Zeno Rocha explores developer-first products' rise, emphasizing their influence on tech adoption and the importance of developer happiness and usability.

The Next Generation of Developer-First Products

Kent C. Dodds opens up the Epic Web Conference with a talk celebrating the aspects of the web that make it awesome (and epic).

The talk, themed "What makes the web epic," opened with Kent expressing enthusiasm about the developments in web technologies and acknowledging the pivotal contributions of web developers through time. The talk celebrated the evolution and resilience of the web in the modern tech era.

Major highlights of the discussion included the reflection on the Webs diversity, flexibility, resilience, and universality. The web's commitment to users, compatibility with older content, and ubiquity across devices and platforms were underscored. Kent emphasized the importance of web standards and preservation in aligning with Tim Berners-Lee's vision of a universally accessible web.

Diverse uses of web technologies also featured in the talk, showcasing their application in automated tasks, household appliances, and even space technology. The web was celebrated as a platform for diverse experiences.

The collaborative ecosystem of the web is another noteworthy point in the talk. Kent acknowledged the importance of community contributions in continually driving the web's innovation and advancement.

The talk concluded with an encouraging note for web developers, stressing the crucial role you play in shaping the web's future, and inspiring you to continue innovating, experimenting, and developing on the web platform.

Kent C. Dodds celebrates the web's diversity and resilience at Epic Web Conference, inspiring developers to shape its future.

What Makes the Web Epic

Barry McGee discusses Shopify's scaling tactics in eCommerce, particularly focusing on adopting AI applications and a React framework. The talk started by outlining Shopify's eCommerce platform's broad reach, including multi-channel sales capabilities and a user-centric tracking feature in the Shopify Shop app.

Shopify's growth motivated the adaptation of Shop Pay and the 'Pay, Track, Repeat' customer retention cycle. The continued expansion triggered the introduction of Shop's web variant, maintaining synchronization between mobile and web platforms.

Barry also covers Shop's decision to move to the web, particularly their shift from using Ruby on Rails towards Remix to capitalize on Shopify's acquisition and the ability to use React across both the mobile and web platforms. This shift aligns with the team's ability to use continuous deployment processes for quicker feedback and easier experimentation.
AI garnered specific attention for its role in enhancing eCommerce product discoverability. Shopify uses AI and natural language processing to refine user search experiences, extending beyond mere keyword matching. An interactive shopping assistant aids the AI models by observing user behavior and collecting feedback.

Shopify recommends simplicity in development, treating URLs as a state's single source of truth and utilizing experiment flags for A/B testing and feature flags for internal testing. These practices are essential for effective upscale operations.

Barry concludes with a summary of critical takeaways, emphasizing starting small, reusing design systems, leveraging native platform capabilities, avoiding over-abstraction, validating processes, and gauging success. These practices have been crucial in the successful scaling of Shop.App with Remix and AI technology.

Barry McGee highlights Shopify's eCommerce scaling, leveraging AI, React, and multi-channel sales for efficient growth and user-centric experiences.

Building shop.app at scale with Remix and AI

There is no great test without a great test name. Here are five tips to help you name your test cases in JavaScript.

1. **Start with a verb**: A test is there to check how something works. So, start its name with a verb. This is one of the simplest ways to introduce consistency to your test names.

```javascript
//❌ Tests validate behaviors.
// Behaviors are actions, actions are verbs!
it("homepage");
it("greeting message");

// ✅ Starting with a verb sets the rest
// of the test name on the right path.
it("navigates to the homepage");
it("displays the greeting message");
```

2. **Use subject-less third person**: In other words, imagine there is "it" before the test name. So, it becomes "fetches the user by ID," "displays the greeting message." Not only will the test names read more naturally this way, but it will also improve their consistency and predictability across the entire code base.

```javascript
//🧐 This is a stylistic tip.
it("fetch the user by id");
it("display the greeting message");

// ✅ Following this tip helps you stay
// consistent in your naming and allows
// to disambiguate between nouns and verbs
it("fetches the user by id");
it("displays the greeting message");
```

3. **Omit implied verbs**: Verbs like "tests," "should," "must," "asserts," and "validates" bring no value to the test name because they're implied. Instead, focus on what it is the test is doing. "Navigates to the homepage," "displays the greeting message," "validates the request headers." This way, you can reduce the visual clutter of the test name and help the test focus on what matters – the intention behind the system.

```javascript
// ❌ Omit verbs like "tests", "should",
// "must", "checks", etc. Those are implied.
it("tests the homepage");
it("should display the greeting message");
it("must validate the request headers");

// ✅ Focus on what the system does.
it("navigates to the homepage");
it("displays the greeting message");
it("validates the request headers");
```

4. **Describe the intention, not the implementation**: I know it may be tempting to put a lot of technical details into the test name. It may even seem useful sometimes, but it's not. Those details bring no value to the test name. They only harm the test.

```javascript
// ❌ Implementation details have no place in tests,
// and that includes the test names.
it("performs a GET request to the /user endpoint");

// ✅ Focus on WHAT the system does, not HOW.
it("fetches the user");
```

5. **Keep it short:** Long sentences can be really great to convey a lot of information, to give a lot of detail and context, but it's not what you want from your test name. Neither is it what you want from your test. You really want it to be focused on one particular thing, one behavior.

In fact, if you have a really long test name, perhaps that's an indication that this test does way too much and should be split in multiple smaller tests.

```javascript
// ❌ Watch out for phrases and flavors
// that bring little value to the test name.
it("redirects the user back to the product detail page");

// ✅ Rephrase, remove repetition, and utilize
// domain-specific terms to keep test names short.
// e.g. PDP = product detail page

it("redirects to the PDP");
```


Discover the importance of well-named test cases and learn five tips to help improve your test naming strategy in JavaScript.

How to Write Better Test Names

It's great that there are so many options in web development, but choosing between tools and frameworks can lead to decision fatigue.

Kent C. Dodds addresses this issue by introducing the Epic Stack, an opinionated yet flexible stack designed to streamline the development process.

The Epic Stack aims to strike a balance between flexibility and over-abstraction by minimizing third-party services, minimizing setup friction, and optimizing for offline development. 

It's not just a project starter kit, but also a reference implementation with comprehensive documentation covering the "why and how" of each part of the stack.

Understanding the Epic Stack will equip you with a structured and adaptable approach to making more informed decisions in your development work, wheter you adopt the stack as-is or use it as a reference in creating your own!

Kent C. Dodds introduces the Epic Stack, a starter kit and reference implementation for building web applications.

The Epic Stack

In this talk, Kent C. Dodds discusses how adopting the philosophy of "Don't solve problems, eliminate them!" can lead to better long-term outcomes.

The concept of the Problem Tree is introduced as a way to think through a problem and its potential approaches to finding solutions (and more potential problems along the way).

Through "real life" examples like electric vehicles eliminating emissions to better air quality as well as code-specific examples including the role of React Hooks in evolving how components are built, Kent makes the case for shifting your problem-solving approach.

Kent C. Dodds discusses how adopting the philosophy of "Don't solve problems, eliminate them!" can lead to better long-term outcomes.

In this talk, Kent C. Dodds discusses the topic of problem-solving in both code and "real life" scenarios. Through a continuous cycle of identifying problems and eliminating them, software is able to evolve to become more ergonomic for the developer and give a better user experience.

Don't Solve Problems, Eliminate Them!

There are two ways to make code faster: Either deleting code, or reducing the amount of operations it is doing. But since deleting code isn't the most practical solution, reducing operations by caching is the preferred approach.

In this talk, Kent C. Dodds explores the fundamentals of caching through a series of illustrated examples.

Topics include working cache keys, cache management, rendering strategy tradeoffs, and other best practices.

Caching is a deep area, but after this talk you'll be prepared to dig in further to determine the best course of action for your own applications!

Kent C. Dodds discusses the fundamentals of caching including vocabulary, solid practices, general considerations, and recommendations.

Talks

A Collection of Epic Web Development talks.