DEV Community: Brylie Christopher Oxley

GitHub Copilot Agent Mode: Enhancing Developer Workflows

Brylie Christopher Oxley — Sun, 13 Apr 2025 06:51:43 +0000

GitHub Copilot has transformed how developers write code, offering suggestions and completing code blocks to speed up development. Now, with the introduction of Agent mode, GitHub has taken AI-assisted development to a new level. This post explores how Copilot Agent mode can enhance your development workflow and help you become more productive.

What is GitHub Copilot Agent Mode?

Agent mode represents a significant evolution in how GitHub Copilot interacts with developers. Unlike the standard Copilot experience, which primarily focuses on line-by-line code suggestions, Agent mode offers a more conversational and context-aware approach to AI assistance.

The key distinction lies in Agent mode's ability to:

Understand complex, multi-step requests
Maintain context throughout a development session
Execute sequences of operations to solve problems
Reason about code structure and architectural decisions
Provide explanations and educational insights alongside code

This shift from reactive suggestions to proactive assistance makes Agent mode feel more like working with a knowledgeable pair programmer than a prediction tool.

Setting Up GitHub Copilot Agent

Before you can leverage Agent mode in your workflow, you'll need to ensure proper setup:

Prerequisites

An active GitHub Copilot subscription
Visual Studio Code with the GitHub Copilot extension installed
The latest extension updates are applied

Configuration Process

Open VS Code and ensure your GitHub Copilot extension is updated
Access the Copilot menu through the status bar icon
Enable Agent mode from the settings menu
Restart VS Code to apply changes

Verification

Try asking a complex question in a comment to verify Agent mode is working correctly. For example:

Can you help me implement a function that reads a CSV file, filters rows based on a condition, and writes the results to a new file?

If Agent mode is configured correctly, you'll see a more comprehensive response that addresses the multi-step nature of your request rather than just code completion.

Practical Applications in Development Workflows

Agent mode shines in several key areas of the development process, offering convenience and efficiency in tasks such as code refactoring, debugging assistance, documentation generation, and architecture planning.

Code Refactoring

Agent mode excels at understanding the structure and purpose of existing code, making it an invaluable tool for refactoring:

# Before refactoring
def process_data(data):
    result = []
    for item in data:
        if item['status'] == 'active' and item['value'] > 100:
            result.append(item['id'])
    return result

With Agent mode, you can ask:

Refactor this function to use list comprehension and add proper error handling

Agent mode will understand both the code's function and your refactoring goals, providing a comprehensive solution.

Debugging Assistance

When facing challenging bugs, Agent mode can help analyze the problem and suggest solutions:

# This function sometimes returns None unexpectedly. Can you identify potential issues?
def get_user_data(user_id):
    response = api.request('users', user_id)
    if response.status == 200:
        return response.data
    if response.status == 404:
        log_error('User not found')

Agent mode will indicate that the function does not have a return statement in the 404 case, which explains why it returns None in that scenario.

Documentation Generation

Creating comprehensive documentation is often tedious but essential. Agent mode can generate detailed documentation based on existing code:

Generate JSDoc comments for this function
function processPayment(userId, amount, currency, method) {
// Implementation details...
}

Agent mode will create appropriate documentation that explains parameters, return values, and potential exceptions.

Architecture Planning

Perhaps most impressively, Agent mode can assist with higher-level architecture decisions:

I need to design a system for processing large CSV files, extracting specific data,
and storing results in a database. What components should I consider, and how might
they interact?

Agent mode can provide architectural guidance, suggesting component structures, potential libraries, and design patterns suited to your needs.

Advanced Techniques

To get the most from Agent mode, consider these advanced techniques:

Customizing Prompts

The effectiveness of Agent mode largely depends on how you communicate your needs. Well-structured prompts yield better results:

Basic prompt:

How do I parse JSON?

Improved prompt:

I need to parse a JSON API response that might contain nested arrays of user objects.
Each user has an 'id', 'name', and 'permissions' field. Show me how to extract all users
with 'admin' in their permissions array.

The detailed context helps Agent mode provide more relevant and helpful assistance.

Integrating With Testing Workflows

Agent mode can streamline test creation:

Write unit tests for this function using pytest

def calculate_discount(order_total, loyalty_tier):
if loyalty_tier == 'gold':
return order_total * 0.15
elif loyalty_tier == 'silver':
return order_total * 0.10
else:
return order_total * 0.05

Agent mode can generate comprehensive tests covering scenarios, edge cases, and expected behaviors.

Using Agent Mode for Code Reviews

Beyond writing code, Agent mode can help with reviewing code:

Review this function for potential issues:

function updateUserProfile(userData) {
    db.connect();
    const user = db.users.findOne({id: userData.id});
    if (user) {
        user.name = userData.name;
        user.email = userData.email;
        db.users.save(user);
    }
    return {success: true};
}

Agent mode might identify issues like:

Missing error handling
No connection closure
No validation of input data
Always returning success even when the user isn't found

Combining With Other Development Tools

Agent mode works best as part of a broader toolset. Consider integrating it with:

Git operations for version control management
Project management tools for task tracking
Testing frameworks for automated quality assurance
Documentation generators for comprehensive technical documentation

Best Practices

To make the most of Agent mode while maintaining code quality:

When to Use Agent Mode vs. Standard Copilot

Use standard Copilot for straightforward code completion, simple functions, and routine coding tasks
Use Agent mode for complex problem-solving, architecture decisions, refactoring, and educational insights

Setting Appropriate Boundaries

While Agent mode is powerful, establish clear boundaries:

Maintain critical thinking about suggestions
Verify security-sensitive code manually
Don't rely on AI for business logic validation
Review generated code for alignment with project standards

Maintaining Code Quality and Ownership

Agent mode is a tool to enhance your capabilities, not replace them:

Understand all code before committing it
Run generated code through your normal testing processes
Document when and how AI assistance was used
Take ownership of the final implementation

Security Considerations

When using AI coding tools:

Never paste sensitive data or credentials in prompts
Review generated code for security vulnerabilities
Be cautious with automatically generated database queries or API calls
Consider running security scanning tools on AI-assisted code

Case Study: Real-World Implementation

Let's examine how Agent mode can transform a real development task:

The Challenge

A developer needs to process a large dataset of customer transactions, identify patterns, and generate a report.

Traditional Approach

Write code to parse the data file
Create filtering logic for relevant transactions
Implement pattern analysis algorithms
Design report generation functionality
Debug each component separately
Integrate the components

This process might take hours or days, depending on complexity.

Agent Mode Approach

The developer provides Agent mode with the high-level requirements:

I need to:

Read a CSV file of transactions (date, customer_id, amount, category)

Identify customers who made > 5 transactions in the "electronics" category

Calculate their average transaction value

Generate a PDF report with this data and some basic visualizations Help me implement this step by step.

Agent mode can:

Generate code for each component
Suggest appropriate libraries for each task
Provide integration guidance
Offer optimization suggestions
Help with debugging issues

The result is a significant reduction in development time and a more robust solution.

Common Challenges

Learning the proper prompting techniques takes practice
Some developers report becoming over-reliant on AI suggestions
Complex, domain-specific problems sometimes require additional guidance

Conclusion

GitHub Copilot Agent mode represents a significant advancement in AI-assisted development. By moving beyond simple code completion to a more conversational, context-aware assistant, Agent mode offers developers a powerful tool for enhancing productivity, quality, and learning.

As with any tool, understanding its capabilities and limitations is the key to success. When used thoughtfully, agent mode can transform your development workflow, freeing you to focus on the most creative and challenging aspects of software creation.

Additional Resources

GitHub Copilot Documentation
Effective Prompting Techniques
GitHub Community Forums
VS Code Extension Marketplace

Note: This blog post reflects the capabilities of GitHub Copilot Agent mode as of April 2025. Features and functionality may evolve as the technology continues to develop.

Gemini 2.5 Pro: A Developer's Guide to Google's Most Advanced AI

Brylie Christopher Oxley — Tue, 01 Apr 2025 05:51:02 +0000

Google recently unveiled Gemini 2.5 Pro, their most intelligent AI model to date. This comprehensive guide examines how it can transform your development workflow, its key capabilities, and practical applications—backed by benchmark data and real-world testing.

Key Capabilities That Matter for Developers

Gemini 2.5 Pro introduces several groundbreaking features that distinguish it from both previous Google models and competitors:

Massive Context Window

The most immediately noticeable improvement is the expanded context window—currently 1 million tokens with plans to expand to 2 million tokens. To put this in perspective:

GPT-4 offers 128K tokens
Claude 3.5 Sonnet offers 200K tokens
Gemini 2.5 Pro offers 1,000K tokens (and soon 2,000K)

This isn't just a number on a spec sheet. For developers, this means:

Analyzing entire codebases (up to ~30,000 lines) in a single prompt
Including comprehensive documentation alongside code
Maintaining context across complex multi-file projects
Eliminating the need for complex chunking and RAG pipelines for most projects

Enhanced Reasoning Capabilities

Gemini 2.5 Pro is designed as a "thinking model," approaching problems with a step-by-step reasoning process rather than rushing to generate a response. This results in:

More accurate debugging of complex issues
Better architectural recommendations that consider multiple factors
Higher quality code generation with fewer bugs and edge cases missed
Improved ability to understand project requirements and constraints

Native Multimodality

While multimodal capabilities aren't new, Gemini 2.5 Pro builds on this foundation with improved integration between different types of inputs:

Analyzing screenshots alongside code
Understanding diagrams and architectural schemas
Processing data visualizations to provide insights
Integrating audio instructions with visual elements

Benchmark Performance: How It Compares

Google has published extensive benchmark data showing Gemini 2.5 Pro's performance across various tasks. Here's how it performs in areas most relevant to developers:

Benchmark	Gemini 2.5 Pro	GPT-4.5	Claude 3.7 Sonnet	Significance for Developers
SWE-Bench Verified	63.8%	38.0%	70.3%	Real-world coding task performance
LiveCodeBench v5	70.4%	-	-	Live coding capabilities
Aider Polyglot	74.0%	44.9%	64.9%	Cross-language code editing
MRCR (128k context)	91.5%	48.8%	-	Long document comprehension

The data shows that while Claude 3.7 Sonnet still leads in some coding-specific benchmarks, Gemini 2.5 Pro offers substantially better performance in long-context understanding—a crucial advantage for complex projects.

Practical Applications for Your Development Workflow

After testing Gemini 2.5 Pro extensively, I've identified several use cases where it excels:

Codebase Analysis and Documentation

With its massive context window, Gemini 2.5 Pro can analyze an entire repository in one go:

// Example prompt:
"I'm sharing my project's codebase. Please analyze its structure,
identify potential architectural issues, and suggest improvements.
Focus on scalability concerns and code organization."

// Then upload the entire project or multiple key files

The model provides comprehensive analysis that considers interactions between components that other models might miss due to context limitations.

Building Complex Web Applications

Gemini 2.5 Pro can generate end-to-end web applications with clean, production-ready code:

// Example prompt:
"Create a React application that displays cryptocurrency price data.
Include a chart component using Recharts, implement pagination,
add filtering by date range, and use proper error handling.
Ensure the code follows best practices for state management."

The generated applications include proper error handling, performance optimizations, and clean component separation—elements often missing from other models' outputs.

Architecture Pattern Implementation

The model excels at implementing complex architectural patterns:

// Example prompt:
"I need to implement a command pattern in my Node.js application
to handle user actions in a more maintainable way. Please provide
a complete implementation with appropriate folder structure,
base classes, and examples of at least 3 different commands."

The results maintain consistency across the implementation, showing understanding of the entire pattern rather than just individual components.

Accessing Gemini 2.5 Pro

You can access Gemini 2.5 Pro through several platforms:

Google AI Studio (Free)

Web-based platform for experimentation
Supports text, image, video, and audio inputs
Offers more prompt control than the Gemini app
Visit Google AI Studio

Gemini Advanced ($19.99/month)

Part of Google One AI Premium subscription
Offers integration with Google Workspace
Includes expanded context window and file upload capabilities
Access via Google One

Vertex AI (Coming Soon)

Enterprise-focused platform
Will offer advanced customization
Suitable for larger teams and projects

Limitations to Be Aware Of

Despite its capabilities, Gemini 2.5 Pro has some limitations developers should consider:

Occasional Code Consistency Issues: When generating very complex applications, it sometimes introduces inconsistencies between components.
Performance Variability: Early users report some inconsistency in performance between the Google AI Studio version and the Gemini app implementation.
Rate Limits: On Vertex AI, the experimental version has strict rate limits (10 queries per minute).
Clarification Patterns: The model sometimes asks multiple clarifying questions, particularly in the Gemini app version, which can slow down the workflow.

Practical Workflow Integration Tips

Based on extensive testing, here are some best practices for incorporating Gemini 2.5 Pro into your development workflow:

Start with Architecture: Use it first for high-level architecture planning and design patterns before diving into implementation details.
Hybrid Approach for Large Projects: For very large projects, combine its analysis capabilities with your own expertise rather than relying on it entirely.
Clear Context Setting: Explicitly define project goals, constraints, and preferences in your prompts for better results.
Incremental Implementation: For complex features, have it generate code incrementally with feedback at each stage rather than all at once.
Platform Selection: Use Google AI Studio for more direct coding tasks and Gemini Advanced when you need deeper integration with Google Workspace.

Conclusion: Is It Worth Adopting?

Gemini 2.5 Pro represents a significant advancement in AI-assisted development, particularly for complex projects requiring deep contextual understanding. While it doesn't completely outperform specialized coding models like Claude 3.7 Sonnet in all benchmarks, its expanded context window and reasoning capabilities make it uniquely valuable for:

Large-scale codebase analysis
Complex architectural planning
Projects spanning multiple files and technologies
Documentation generation and improvement

For most developers, the free Google AI Studio access provides an excellent entry point to experiment with these capabilities and determine if the advanced features warrant a Gemini Advanced subscription.

Resources

Have you tried Gemini 2.5 Pro for your development work? Share your experiences in the comments below!

This post is part of our AI for Developers series exploring practical applications of AI models in software development workflows.

The State of Open-Source Tailwind CSS Component Frameworks: A Developer's Guide

Brylie Christopher Oxley — Sat, 22 Feb 2025 15:13:41 +0000

As Tailwind CSS continues to reshape the frontend development landscape, we're seeing a flourishing ecosystem of component frameworks emerge. This 'State of Open-Source Tailwind CSS Component Frameworks' is a comprehensive overview of the current landscape, highlighting the most notable frameworks that embrace open-source principles and avoid freemium models favoring community-driven development. While commercial options like Tailwind UI offer polished solutions, many developers are turning to open-source alternatives that provide greater flexibility and transparency. Let's explore the most notable frameworks that embrace open-source principles, avoiding freemium models favoring community-driven development.

FlyonUI: Bridging Semantic Classes and JavaScript Functionality

FlyonUI is not just another component library. It's an innovative approach that combines the benefits of semantic class naming with the power of headless JavaScript plugins. Built on the solid foundations of Tailwind CSS and DaisyUI, it incorporates Preline's JavaScript capabilities to create a comprehensive solution for modern web development.

What makes FlyonUI particularly interesting is its solution to a common challenge in Tailwind development: balancing maintainable code and interactive functionality. While Tailwind's utility classes offer tremendous flexibility, they can also lead to cluttered HTML that is difficult to maintain. FlyonUI addresses this by providing 'semantic class names ', which are class names that describe the content they are applied to. This makes the HTML clean and readable while still incorporating the interactive elements modern applications require.

The framework offers several compelling features:

Semantic styling that keeps HTML clean and readable
Integration with headless JavaScript plugins for interactive components
Universal framework compatibility across React, Vue, and other ecosystems
Built-in support for RTL languages and responsive design
Extensive theming capabilities for customization

FlyonUI's approach is particularly valuable for teams transitioning from traditional CSS frameworks to the utility-first world of Tailwind, as it provides a familiar semantic structure while maintaining access to Tailwind's powerful features.

DaisyUI: Semantic Simplicity in the Tailwind Ecosystem

DaisyUI has established itself as a foundational component library in the Tailwind ecosystem. It offers a familiar, Bootstrap-like development experience. Its semantic class system simplifies component reuse, providing pre-styled elements without requiring proprietary dependencies.

DaisyUI strikes a perfect balance between simplicity and customization. It's not just about providing pre-styled elements; it offers surprising flexibility through its extensive theming capabilities and modifier classes. This reassures developers that they can achieve design uniformity in collaborative environments without sacrificing creative freedom.

Shadcn/ui: Rethinking Component Distribution

Shadcn/ui takes an innovative approach to component distribution that's worth understanding. Rather than operating as a traditional npm package, it provides unstyled, accessible components that developers copy directly into their projects. This "copy-paste" methodology, combined with Tailwind's utility classes, offers several advantages:

Complete control over component implementation
There are no runtime dependencies to manage
Freedom to modify and adapt components without framework constraints
Direct integration with your project's design system

This approach has sparked an entire ecosystem of derivative works, including adaptations for frameworks like Svelte and Blazor. The growing community around shadcn/ui demonstrates how open-source principles can foster innovation while maintaining high standards for accessibility and performance.

Preline UI: Enterprise Focus with Developer Freedom

Preline UI distinguishes itself by focusing on enterprise applications while maintaining the flexibility developers need. Its MIT license and comprehensive documentation make it particularly appealing for teams building complex applications. The framework excels in providing components for data-intensive interfaces and administrative dashboards.

One of Preline's standout features is its design system integration, which offers Figma resources to ensure consistency between design and implementation. This bridge between design and development workflows has made Preline increasingly popular among full-stack teams that need to maintain coherent user experiences across large applications.

The Rise of Headless Components

The trend toward headless components, exemplified by libraries like shadcn/ui and integrated into frameworks like FlyonUI, represents a significant shift in how we think about component libraries. These frameworks provide the logic and accessibility features while leaving styling decisions entirely to developers. This approach offers several benefits:

Greater design flexibility
Reduced bundle sizes
Better integration with existing design systems
Improved performance through customization
Enhanced debugging capabilities

The success of this model has influenced newer frameworks to adopt similar principles, leading to a more modular and maintainable ecosystem.

Evaluating Open-Source Frameworks: Key Considerations

When choosing an open-source Tailwind component framework, consider these factors:

Community Activity

Look for active GitHub repositories with regular commits, thoughtful issue discussions, and responsive maintainers. A vibrant community often translates to better documentation, more examples, and faster bug fixes.

Documentation Quality

Comprehensive documentation with live examples and clear implementation guidelines is crucial. The best frameworks provide both basic usage examples and advanced customization scenarios.

Framework Compatibility

Ensure the library works well with your chosen JavaScript framework. While many libraries focus on React, some offer excellent support for Vue, Angular, or Svelte.

Customization Options

The ability to modify components without fighting the framework is essential. Look for libraries that provide clear customization APIs and don't lock you into specific design decisions.

Bundle Size Impact

Consider how the framework affects your application's bundle size. Headless components and tree-shakeable libraries often provide better performance optimization opportunities.

Looking Ahead

The Tailwind CSS component ecosystem continues evolving, with new frameworks and existing ones adapting to changing developer needs. The trend toward truly open-source solutions has fostered innovation and improved code quality across the ecosystem.

When evaluating these frameworks for your next project, remember that the best choice depends on your specific needs:

For a balance of semantic classes and JavaScript functionality, FlyonUI offers a comprehensive solution
For rapid prototyping and quick wins, DaisyUI provides an excellent starting point
When maximum control is needed, shadcn/ui's copy-paste approach provides unmatched flexibility
For enterprise applications, Preline UI delivers a robust foundation with professional-grade components

The future looks promising for open-source Tailwind component frameworks, with an increasing focus on accessibility, performance, and developer experience. We expect to see even more innovative component distribution and customization approaches as these libraries mature.

Conclusion

The rise of open-source Tailwind CSS component frameworks has democratized access to high-quality UI components while promoting transparency and community collaboration. Whether you're building a small project or an extensive enterprise application, these frameworks offer compelling alternatives to commercial solutions.

Remember that the best framework for your project isn't necessarily the one with the most components or features but the one that best aligns with your team's workflow and project requirements. Experiment with different options and contribute to the communities that resonate with your development philosophy.

This article reflects the state of Tailwind CSS component frameworks as of early 2025. Given the rapid evolution of frontend development, check the latest documentation and community discussions when deciding.

Crafting a Theme-Toggle Flutter App: Switch Between Light and Dark Modes with Ease

Brylie Christopher Oxley — Tue, 07 Nov 2023 06:53:26 +0000

As more users come to expect a customizable viewing experience in their apps, providing a light/dark mode toggle has become a staple in app development. Flutter, with its rich set of widgets and properties, makes this not only possible but pleasantly straightforward. In this post, we'll walk through how to add a theme toggle to your Flutter app, complete with intuitive sun and moon icons.

Let's start by setting the stage with our main function and DarkLightApp widget. We launch our app with runApp(const DarkLightApp()), which serves as the entry point. Our DarkLightApp is a StatefulWidget because theme toggling will change the app's state.

void main() {
  runApp(const DarkLightApp());
}

class DarkLightApp extends StatefulWidget {
  const DarkLightApp({super.key});
  @override
  _DarkLightAppState createState() => _DarkLightAppState();
}

Next, we define _DarkLightAppState to hold our theme state. We initialize our theme mode to dark with ThemeMode _themeMode = ThemeMode.dark.

class _DarkLightAppState extends State<DarkLightApp> {
  ThemeMode _themeMode = ThemeMode.dark;
  ...
}

Our _toggleTheme function takes a boolean isOn and sets the theme mode to light or dark, depending on the switch's position. This is where setState shines, notifying the framework to redraw the widget with the updated theme mode.

void _toggleTheme(bool isOn) {
  setState(() {
    _themeMode = isOn ? ThemeMode.light : ThemeMode.dark;
  });
}

In the build method, we craft our MaterialApp, which now includes the theme toggling logic. By setting debugShowCheckedModeBanner to false, we ensure a clean UI without the debug tag.

@override
Widget build(BuildContext context) {
  return MaterialApp(
    title: 'Dark/Light App',
    debugShowCheckedModeBanner: false,
    ...
  );
}

For our themes, we define both darkTheme and theme. The darkTheme uses Brightness.dark, while theme uses a color scheme seeded with blue for light mode.

darkTheme: ThemeData(
  brightness: Brightness.dark,
),
theme: ThemeData(
  colorScheme: ColorScheme.fromSeed(seedColor: Colors.blue),
  useMaterial3: true,
),

Now, the star of our UI: the Scaffold within MaterialApp's home. The AppBar not only holds our title but also a Row of Icons and a Switch that control the theme mode.

home: Scaffold(
  appBar: AppBar(
    title: const Text('Dark/Light App'),
    actions: [
      Icon(Icons.dark_mode),
      Switch(
        value: _themeMode == ThemeMode.light,
        onChanged: _toggleTheme,
      ),
      Icon(Icons.light_mode),
    ],
  ),
  body: const Center(
    child: Text('Hello World'),
  ),
),

The Switch widget toggles the theme mode and, flanked by the sun (Icons.light_mode) and moon (Icons.dark_mode) icons, provides a clear visual cue for its function.

By using Flutter's ThemeData and ThemeMode, we created a seamless way to allow users to switch between light and dark themes. This not only caters to their visual preferences but also can help save battery life on OLED screens and reduce eye strain in low-light conditions.

Implementing a theme toggle in your Flutter app not only enhances the user experience but also showcases the dynamic capabilities of your app. With just a few lines of code, you can give your users the power to choose their preferred theme, making your app more inclusive and user-friendly.

Happy coding!

The Role of Software Engineers in Combatting Climate Change

Brylie Christopher Oxley — Thu, 15 Jun 2023 11:29:17 +0000

Climate change is a global issue affecting everyone on this planet. It is one of the most significant challenges that we are facing today. The effects of climate change can be devastating, and we need to take urgent action to combat it. Software engineers can play a significant role in combating climate change. In this article, we will discuss the role of software engineers in combating climate change.

Develop Sustainable Software
Participate in climate-change hackathons
Collaborate with climate scientists
Influence Public Policy
Tools and Resources for Sustainable Software Development
- Energy-Efficient Coding Libraries
- Tools for Measuring Energy Consumption
- Tutorials and Courses
Tangible Benefits of Combating Climate Change for Software Developers
- Skill Enhancement and Career Advancement
- Increased Efficiency and Cost Savings
- Networking and Collaboration
- Making a Positive Impact
Roadmap for an Environmentally-Focused Engineering Career
Call to Action

Develop Sustainable Software

Software engineers can develop sustainable software that is environmentally friendly. Sustainable software is designed to minimize the impact on the environment. It is designed to be energy-efficient, use fewer resources, and have a minimal carbon footprint. For example, software engineers can develop software that uses less power, which can reduce the energy consumption of a data center. They can also develop software for low-power devices like smartphones and tablets.

Software engineers can develop sustainable software by implementing several practices and technologies. Here are a few examples:

Energy-efficient algorithms: Develop algorithms requiring less computation or parallel processing to reduce energy consumption.
Virtualization: Use virtualization technologies to consolidate servers and reduce the number of physical servers required, reducing energy consumption.
Cloud computing: Moving applications and data to the cloud can help reduce energy consumption by leveraging economies of scale.
Optimizing code: Optimize code to reduce CPU usage and memory consumption, which can lead to energy savings.
Energy-aware programming: Use energy-aware programming techniques to optimize energy consumption, such as reducing screen brightness on mobile devices.

By incorporating these practices into their software development projects, software engineers can contribute to combating climate change by reducing the carbon footprint of their software.

Participate in climate-change hackathons

Hackathons focused on climate modeling can be an excellent way for developers to get involved and contribute to open science. These events bring together experts from different fields to work on climate modeling projects and develop innovative solutions.

Here are some climate modeling hackathons that focus on public participation in science and promoting a sustainable future:

Hack4Climate: An annual hackathon that aims to create solutions to combat climate change and promote a sustainable future.
Climathon: A global movement that brings together cities, innovators, and businesses to find solutions to climate change challenges.
Earth Hacks: A hackathon focusing on creating solutions to environmental problems, including climate change.
Hack the Planet: A hackathon that focuses on finding solutions to mitigate the effects of climate change.
EcoHack: A hackathon that brings developers, designers, and sustainability experts together to create solutions for a sustainable future.

Participating in these hackathons is an excellent way for developers to get involved in climate modeling and contribute to promoting a sustainable future.

Collaborate with climate scientists

Collaboration with climate scientists can help developers better understand the challenges of climate modeling and how they can contribute to open science. By working closely with climate scientists, developers can gain insights into the data and models used in climate research and contribute to open science by improving these models and making them more accessible.

Software engineers can help develop climate models that can help predict future weather patterns. These models can help us better understand the impact of climate change and develop strategies to combat it. Climate models can help us predict the effects of rising sea levels, increased temperatures, and extreme weather events. Software engineers can design and develop these models, which can help us make informed decisions about combatting climate change.

Many open-source climate modeling software projects accept contributions from developers. Contributing to these projects can help improve the accuracy of climate models and make them more accessible to researchers and policymakers.

Here are a few open-source climate modeling software projects or initiatives:

Community Earth System Model (CESM): is a fully coupled global climate model developed collaboratively by the research community. It is primarily supported by the National Science Foundation (NSF) and is maintained by the Climate and Global Dynamics Laboratory (CGD) at the National Center for Atmospheric Research (NCAR). The CESM project has a public code repository on GitHub that developers can contribute to.
ClimatePrediction.net: is a volunteer computing climate modeling project. They run climate models on people's home computers to help answer questions about how climate change affects our world. The data generated from these models are then sent back and incorporated into the climate prediction projects. This project is run by the University of Oxford and the Open University.
The Climate Data Initiative: An initiative launched by the White House to make climate data more accessible and valuable to researchers, businesses, and the public. The initiative includes several open-data projects that developers can contribute to.
The Goddard Institute for Space Studies (GISS) ModelE: A global climate model developed by NASA's Goddard Institute for Space Studies. The GISS series of coupled atmosphere-ocean models use a framework called ModelE, which can simulate many different configurations of Earth System Models. This series has been used since 2004. The GISS ModelE project has a public code repository on GitHub that developers can contribute to.
The European Centre for Medium-Range Weather Forecasts (ECMWF): A European intergovernmental organization that provides numerical weather predictions to its member states. The ECMWF provides a public data archive for developers to develop and test climate models.
The Community Climate System Model (CCSM): A suite of climate models developed by the National Center for Atmospheric Research (NCAR) and supported by the National Science Foundation (NSF).
The Weather Research and Forecasting Model (WRF) is a state-of-the-art mesoscale numerical weather prediction system designed for atmospheric research and operational forecasting applications. It's currently in operational use at the National Centers for Environmental Prediction (NCEP) and other national meteorological centers and in real-time forecasting configurations at laboratories, universities, and companies. The WRF project has a public code repository on GitHub that developers can contribute to.

By contributing to these projects and initiatives, developers can collaborate with climate scientists to tackle significant issues with climate change and make a difference in the fight against climate change.

Influence Public Policy

Software developers have a unique perspective on the practicalities of implementing sustainable software practices, and this insight is valuable in shaping public policy. Developers can contribute to policy discussions, advocate for legislation that supports sustainable software practices, and work on open-source projects that provide the tools and data needed for informed policy-making.

Here are a few ways that developers can influence public policy:

Engage in Discussions: Developers can participate in public forums, write articles, or use social media to discuss the impact of software on the environment and the importance of sustainable practices. By sharing their knowledge and experiences, they can help inform the public and policymakers about these critical issues.
Advocate for Legislation: Developers can advocate for laws and regulations that promote energy-efficient coding practices and sustainable software development. This could involve writing to local representatives, signing petitions, or supporting organizations that lobby for these issues.
Contribute to Open-Source Projects: Many open-source projects provide vital data and tools for climate change research and policy-making. By contributing to these projects, developers can help improve the resources available for creating informed climate policies.
Partnerships with Policymakers: Developers can also collaborate directly with policymakers by providing technical advice or developing software tools for policy analysis.

Remember, policy change often starts with awareness. By using their skills and knowledge, developers have the power to drive significant policy changes that support a sustainable future.

Tools and Resources for Sustainable Software Development

Whether you're just starting your journey toward sustainable software development or looking to refine your skills, numerous resources can guide you. From energy-efficient coding libraries to tools for measuring the energy consumption of software, the following resources can help developers create more sustainable, climate-friendly software:

Energy-Efficient Coding Libraries

Libraries like Google's TensorFlow Lite and Facebook's EfficientNet are designed to create efficient machine learning models for mobile and the web. They optimize for performance and size, making them energy-efficient options.

Tools for Measuring Energy Consumption

Tools such as Intel's Energy Profiler or Joulescope can help you understand the energy consumption of your software and embedded hardware. These tools provide insights into how your code uses energy, allowing you to identify areas for optimization.

Tutorials and Courses

Many online resources can help you learn how to code more sustainably. For instance, The Green Software Foundation offers best practices, case studies, and other resources to promote sustainable software engineering. Websites like Coursera, edX, and Udacity also offer courses on sustainable software development and related topics.

These resources are just the starting point—there's a wealth of knowledge and tools for developers interested in sustainable software development. By leveraging these resources, developers can create powerful, efficient, and environmentally friendly software.

Tangible Benefits of Combating Climate Change for Software Developers

While the benefits of sustainable software development to the environment are clear, the advantages for software developers themselves are just as significant. By engaging in sustainable practices and initiatives, software developers stand to gain valuable skills, experiences, and opportunities that can enhance their careers and personal growth. Here are a few concrete benefits that may inspire software developers to dive into the realm of climate change mitigation:

Skill Enhancement and Career Advancement

Sustainable software development requires a unique set of skills and knowledge. Developers can expand their skill sets and differentiate themselves in the job market by learning to develop energy-efficient algorithms, optimize code for low energy consumption, and employ virtualization and cloud computing effectively.

Additionally, contributing to open-source climate modeling projects allows developers to work on complex, high-impact problems. These experiences can be significant resume boosters and lead to advanced career opportunities in data science, machine learning, and high-performance computing.

Increased Efficiency and Cost Savings

Sustainability practices often align with principles of efficient software development. For example, energy-efficient code is typically faster and uses fewer resources, which can lead to significant cost savings, especially at scale. This is not only beneficial for the environment but also for the bottom line of businesses.

Networking and Collaboration

Engaging in climate change initiatives offers excellent opportunities for networking and collaboration. Participating in hackathons or contributing to open-source projects allows developers to connect with experts from diverse fields, including climate science, data analysis, and policy-making. These collaborations can lead to lasting professional relationships and open new opportunities.

Making a Positive Impact

Last, contributing to the fight against climate change can bring a strong sense of purpose and fulfillment. As a software developer, you have the potential to make a significant positive impact on one of the most pressing issues of our time. Your work can directly contribute to developing climate models that inform policy decisions or creating sustainable software that reduces carbon emissions. This sense of purpose can lead to increased job satisfaction and motivation.

Roadmap for an Environmentally-Focused Engineering Career

Starting a career in environmentally-focused software engineering may seem daunting, but with a clear roadmap, you can navigate this path effectively. Here's a step-by-step guide to help you get started:

Equip Yourself with Necessary Knowledge: Start by educating yourself about climate change, its causes, and its impacts. This understanding will help you grasp the urgency of the issue and the role that technology can play in mitigating it.
Learn About Sustainable Software Engineering Practices: This includes familiarizing yourself with energy-efficient algorithms, optimizing code for energy efficiency, understanding the principles of green software engineering, and learning how to measure the environmental impact of your software. Many online resources and courses are available that cover these topics.
Hands-On Experience: Participate in environmentally-focused hackathons or projects. These events offer practical experience and expose you to the latest ideas and technologies in the field. They also provide opportunities to network with like-minded individuals and organizations.
Contribute to Open Source Projects: Open source projects like the Community Earth System Model (CESM), the Goddard Institute for Space Studies (GISS) ModelE, and the Weather Research and Forecasting Model (WRF) are great platforms to contribute to. Working on such projects will help you understand the real-world applications of your skills and contribute to meaningful climate change solutions.
Collaborate with Climate Scientists: Software engineers and climate scientists can achieve more by working together. Seek opportunities to work with climate scientists, understand their data and models, and contribute to their refinement and accessibility.
Continuous Learning and Improvement: The field of green software engineering is dynamic and evolving. Stay updated with the latest research, tools, and practices. Attend seminars, workshops, and conferences on sustainable software development and climate change.
Advocate and Educate: As you gain experience and knowledge, share it with others. Advocate for sustainable practices within your organization, write blog posts, give talks, and educate others about the importance of sustainable software engineering.

Remember, this is a journey. Each step you take towards becoming an environmentally-focused software engineer makes a difference. In the wise words of Lao Tzu, "A journey of a thousand miles begins with a single step." Start today and code for a better tomorrow.

Call to Action

Now that you understand how software development intersects with climate change and sustainability, it's time to take action. As a software developer, you have the power to impact the future of our planet directly.

Whether it's optimizing your code to be more energy-efficient, contributing to open-source climate modeling projects, or integrating sustainable practices into your workplace, every action counts. The tools and resources are at your fingertips—use them to create powerful, efficient, and environmentally conscious software.

Remember, the code we write today will shape the world of tomorrow. Let's code for a sustainable future.

Enhancing GitHub Copilot's Efficiency: Providing Meaningful Context

Brylie Christopher Oxley — Fri, 02 Jun 2023 06:45:46 +0000

Hello, fellow coders!

Let's will delve into a simple yet crucial aspect of leveraging the power of AI in our coding journey, mainly focusing on GitHub Copilot, an AI-powered coding assistant.

Why Context Matters in AI Coding
The Power of Import Statements
More Than Just Imports
Code example
The Human Touch
Conclusion

Why Context Matters in AI Coding

Just like humans, AI tools like GitHub Copilot need a good amount of context to provide the best possible assistance.

Suppose you ask Copilot to generate code, such as a unit test. It will produce a better result if it understands the broader scenario. That's where 'import statements' come in handy.

The Power of Import Statements

In most programming languages, such as Dart, Python, or JavaScript, we use import statements to include libraries or modules in our project. These imports allow us to utilize prewritten code, like functions or classes, while keeping our project organized. For instance, if you plan to manipulate data in Python, you might import pandas at the start of your code.

Adding these import statements before asking Copilot to generate code gives the AI a clear idea of what resources it has at hand. So, if you've imported pandas, Copilot knows it can use pandas' functions in the code it generates!

More Than Just Imports

While imports are a good start, you can provide even more context. For example, naming your variables meaningfully, specifying their types, or writing explicit comments about what you want to do can help Copilot generate more accurate and helpful code.

Imagine if a friend asked you to write a story but gave no details. That's like being asked to find the 'most whimsical seagull' on a beach. But, if they told you they wanted a saga about a seagull who moonlights as a detective solving the mystery of missing french fries (plot twist, the seagull is also the thief), you'd instantly have more direction, wouldn't you? Similarly, the more detail you give Copilot, the better it can assist you.

Code example

A quick code example will help illustrate these prompting techniques.

# Importing Python's built-in `re` module for regex operations 
# since it will be useful
import re

# We have a text description of our cozy, secluded beach town.
# Perhaps it holds some clues about our missing french fries!
a_cozy_secluded_beach_town: str = """
Welcome to our cozy, secluded beach town 🏖️. With a vibrant 
community of seagulls, it's well known for its delectable 
boardwalk french fries, which tend to mysteriously disappear 
occasionally.
"""

# Now, let's create a function to hunt down mentions of these famous french fries.
def find_french_fries_in_text(text: str) -> str:
    """
    🔎 This function searches for the term 'french fries' 
    in the provided text.
    💬 It prints a message indicating whether the fries 
    have been found or not.
    """
    # Let's ask Copilot to write the regex search for us.
    # Remember, GitHub Copilot, we are searching for 'french fries'.

With this setup, you can use GitHub Copilot to generate the following code:

    match = re.search('french fries', text)
    if match:
        print("🍟 We've found the french fries!")
    else:
        rprint("😭 The fries are still missing!")

Admittedly, the amount of prompting outweighs the generated code in this example. However, you can imagine a more complex situation where the desired code output isn't as straightforward as finding "french fries" in a description of a beach town. So remember, the more breadcrumbs (or should we say crispy fries?) you leave for Copilot, the better it can help you!

The Human Touch

As impressive as AI is, remember it's not perfect (and nor are we.) It's important to always review the code that Copilot generates, similarly to how we have peer-review for our code. This way, you help ensure the code is correct, efficient, and secure.

Conclusion

In summary, GitHub Copilot is a fantastic tool to enhance our coding productivity. However, it is most effective when provided with ample context. And, like any other tool, it should be used with a healthy dose of human judgment and review.

So, next time you use GitHub Copilot, try these tips and see how they can help you code more efficiently!

Keep coding and stay curious!

Steering the Future: An Introduction to Artificial Intelligence Alignment

Brylie Christopher Oxley — Wed, 31 May 2023 12:27:15 +0000

Artificial Intelligence (AI) has become an integral part of our daily lives, with applications spanning various industries such as healthcare, finance, transportation, and entertainment. As AI systems become more complex and autonomous, ensuring they act according to human values and societal expectations becomes a paramount concern. This concept is often referred to as "AI alignment." In this article, we will delve into the heart of AI alignment, exploring its significance, challenges, and strategies to solve it.

What is AI Alignment?

AI alignment is a field of research primarily concerned with ensuring that the behavior of AI systems is in line with human values. The goal is to ensure that as AI advances, the systems we create are not just competent but also beneficial to us and act in ways that we deem acceptable, ethical, and advantageous.

AI alignment involves two crucial components: designing AI that wants to do what humans wish to (the "value alignment" problem) and creating AI that understands what humans want to do (the "interpretation" problem). Both are considerably challenging but also profoundly essential to ensure advanced AI's safe and beneficial use.

The Importance of AI Alignment

AI alignment is a critical concern for several reasons:

Safety: Misaligned AI could potentially pose risks. Even if an AI system is not inherently malicious, it might inadvertently cause harm if its objectives aren't correctly aligned with human values.
Ethics: AI systems are being deployed in increasing sectors, making decisions that affect human lives. Therefore, these systems must reflect our ethical standards and societal norms.
Long-term Future: As we create more advanced and general AI systems, the consequences of misalignment could become increasingly severe, possibly life threatening. Thus, it's vital to proactively address AI alignment.

Challenges of AI Alignment

AI alignment is an active research field due to several significant challenges:

Complexity of Human Values: Human values are complex, context-dependent, and often implicit, making them challenging to define and encode into an AI system.
Value Extrapolation: Even if we manage to encode our values into an AI system, those values might need to evolve as our society progresses, requiring the AI system to understand and extrapolate these changes appropriately.
Diverse Perspectives: Humans do not all share the same values or priorities, creating challenges for designing universally acceptable AI systems.

Current Strategies and Research Directions

AI researchers are exploring various strategies to address the problem of AI alignment:

Inverse Reinforcement Learning (IRL): IRL is a technique to infer the desired goals from observed behavior. The hope is to apply similar methods to infer human values and implement them into AI systems.
Cooperative Inverse Reinforcement Learning (CIRL): CIRL is an extension of IRL where both the AI system and the human are seen as part of the same team, collaborating to achieve the desired goal.
Interpretability Research: Understanding how AI makes decisions can help humans correct misaligned behavior. Hence, there's significant interest in making AI systems more interpretable.
Debate and Amplification: These are techniques where multiple AI systems are pitted against each other to debate a given question or take turns improving each other's answers under human supervision.

Conclusion

AI alignment is our guide star in the fast-moving world of artificial intelligence. It's a nuanced issue, but with forethought and persistence we can plot the course. By defining our values, taking measured actions, and doing careful research, we're sure to make AI our powerful ally in building a brighter, more prosperous future for all.

Pagination with Django and Bootstrap 5

Brylie Christopher Oxley — Mon, 14 Mar 2022 09:56:32 +0000

In this recipe, we will use Django pagination to display a paginated list of Items and add Bootstrap 5 styles. Replace the Item class with any Django model in your own project.

Create the paginated list

In the View, such as in the get_context method of a class-based view:

# Add these imports at the top of your View file
from django.core.paginator import (
    Paginator,
    EmptyPage,
    PageNotAnInteger,
)

# Then, in the view, such as the get_context method:

# Get page number from request, 
# default to first page
default_page = 1
page = request.GET.get('page', default_page)

# Get queryset of items to paginate
items = Item.objects.all()

# Paginate items
items_per_page = 10
paginator = Paginator(items, items_per_page)

try:
    items_page = paginator.page(page)
except PageNotAnInteger:
    items_page = paginator.page(default_page)
except EmptyPage:
    items_page = paginator.page(paginator.num_pages)

# Provide filtered, paginated library items
context["items_page"] = items_page

Render the paginated items and paginator widget

Once you have passed the paginated items to the template, render the items along with a paginated button group.

{% if items_page %}
    {% for item in items_page %}
        <div class="card mb-1">
            <div class="card-body">
              <p class="card-title">{{ item.title }}</p>
            </div>
        </div>
    {% endfor %}

    {% if items_page.has_other_pages %}
    <div class="btn-group" role="group" aria-label="Item pagination">
        {% if items_page.has_previous %}
            <a href="?page={{ items_page.previous_page_number }}" class="btn btn-outline-primary">&laquo;</a>
        {% endif %}

        {% for page_number in items_page.paginator.page_range %}
            {% if items_page.number == page_number %}
                <button class="btn btn-outline-primary active">
                    <span>{{ page_number }} <span class="sr-only">(current)</span></span>
                </button>
            {% else %}
                <a href="?page={{ page_number }}" class="btn btn-outline-primary">
                    {{ page_number }}
                </a>
            {% endif %}
        {% endfor %}

        {% if items_page.has_next %}
            <a href="?page={{ items_page.next_page_number }}" class="btn btn-outline-primary">&raquo;</a>
        {% endif %}
    </div>
    {% endif %}
{% else %}
    <p>No items found.</p>
{% endif %}

Install Flutter on Ubuntu 21.10 with Snap and APT

Brylie Christopher Oxley — Thu, 24 Feb 2022 11:39:54 +0000

Follow these steps to install Flutter, Java (OpenJDK), Android Studio, Chromium, and Visual Studio Code on Ubuntu 21.10.

We use Snap and APT to make it easy to keep these packages up-to-date.

Flutter

Install the official Flutter Snap package with classic permissions.

sudo snap install flutter --classic

Java SDK (OpenJRE)

As of this writing, OpenJDK 11 is the default JDK on Ubuntu 21.10.

sudo apt install default-jdk

Android Studio

Install Android Studio via Snap with classic permissions.

sudo snap install android-studio --classic

Chromium

Install the Chromium browser via Snap.

sudo snap install chromium

CHROME_EXECUTABLE

Next, set the CHROME_EXECUTABLE to the Chromium installation path.

Assuming your default shell is bash, add the following to .profile or .bash_profile if it exists.

Note: you may need to log out and back in after running the following command.

echo "export CHROME_EXECUTABLE=/snap/bin/chromium" >> ~/.profile

Visual Studio Code

Install the Visual Studio Code IDE via Snap.

sudo snap install code --classic

Flutter extension

Open Visual Studio Code and install the Flutter extension.

Flutter Doctor

Finally, verify that everything was installed correctly by running Flutter Doctor.

flutter doctor

Conclusion

In this quick overview, we have installed a full Flutter development environment in Ubuntu 21.10.

I hope you enjoy seeing your ideas take flight with Flutter :-)

PostgreSQL Foreign Data Wrapper tutorial

Brylie Christopher Oxley — Fri, 18 Dec 2020 10:20:56 +0000

A PostgreSQL Foreign Data Wrapper (FDW) allows you to write queries against a remote database.

Considerations

While some FDW tradeoffs are not immediately apparent, at least a few come to mind more readily.

Schema drift

The remote schema may change. However, the FDW schema is generated at a single point in time (based on the remote schema). This may lead to the FDW schema being out of sync with the remote schema.

One solution to this issue would be to re-generate the FDW schema on a periodic basis.

User permissions

Each database user needs an individual user mapping for the remote database server. This may not be an issue on a single-user system, but can be a bit more annoying in a multi-user environment.

Queries

The following sections outline the queries necessary to connect to a remote database, create a mirror schema, and assign user permissions to the foreign data source.

Create FDW extension

Make sure PostgreSQL has the FDW extension enabled.

create extension if not exists postgres_fdw;

Create FDW server

Create the FDW server by giving it a local name and remote connection details.

create server <fdw_server_name>
foreign data wrapper postgres_fdw
options (host 'dbms.example.com', dbname 'database_name');

Create mirror schema

Create an empty schema in the local database and populate it with matching table definitions from the remote database schema.

create schema <local_schema_name>;

import foreign schema <remote_schema_name>
from server <fdw_server_name>
into <local_schema_name>;

Create FDW user mapping

For each user who needs to interact with the foreign server, we need to create a user mapping.

The local user will have the same permissions on the FDW server as the remote user defined in the user mapping.

create user mapping for <user_name>
server <fdw_server_name>
options (user 'remote_user_name', password 'remote_user_password');

References

PostgreSQL (current) documentation - postgres_fdw module
thoughtbot - PostgreSQL's Foreign Data Wrapper

Mailchimp makes contact management difficult

Brylie Christopher Oxley — Wed, 22 May 2019 14:42:53 +0000

TLDR: Mailchimp should offer a unified 'contacts manager' to help users effectively manage their contact list. This would help reduce waste and honor communications preferences for recipients.

Background

While helping our marketing team manage contacts, I learned that we had around 45% - 55% duplicate records across several of what Mailchimp calls "audiences". At first, I was concerned about the data practices of the marketing team, but then I realized that part of the issue was related to the Mailchimp interface. In particular, Mailchimp doesn't seem to allow customers to manage a unified contacts list.

Current design

The Mailchimp Dashboard menu consists of the following top-level sections:

Of note, the Audience link is singular, implying that there is one core audience, perhaps broken into overlapping segments (my interpretation).

Having a segmented audience is easy to understand from a marketing perspective. Conceptually, an audience is all of the people interested in your offering. Segments would then be audience members grouped into various demographics, useful for tailored communication.

Design implications

In practice, Mailchimp audiences are distinct contact lists that allow duplicate contacts to exist in multiple audiences.

Contacts can sometimes have opted out of one "audience", having no effect on their communications preferences in another audience. This can cause frustration when contacts receive communications after having opted-out. It can also lower a company's reputation, particularly when users report the company's communications as SPAM.

Likewise, your company will be billed for duplicate contacts across audiences, as if they were distinct contacts. This might be unnoticeable for smaller contact lists, but is still wasteful (like leaving the lights on when you're not home).

Impact

In our case, we had the same contacts in as many as five audiences. This was adding up to several hundred euros a month, just to pay for duplicate contacts.

After archiving and merging contacts from the multiple duplicate "audiences" that our marketing team had created, we reduced our contact count by almost half!

Financial conflict-of-interest

Whenever we use a service company (be it AWS, Mailchimp, etc) that charges based on resource usage, that company has financial incentive to encourage inefficient, or excessive, use of the related resource(s).

In this case, Mailchimp stands to lose a considerable portion of recurring revenue, if it were to engineer unified contact management and de-duping into its platform. That said, it is not a foregone conclusion that Mailchimp won't offer effective contact management at some point in the future.

Not placing blame

I don't believe the fault here lies completely on the marketing team or Mailchimp, but the combination of inadequacies in Mailchimp contact management and choices made by the marketing team added up to a costly monthly bill.

Conclusion

I am not saying that Mailchimp is a bad actor here -- far from that since they provide a user-friendly, honest service.

I am just staying that Mailchimp contact management could use some significant improvement.

This work is licensed under a Creative Commons Attribution 4.0 International License.

Don't use "sudo" with NPM "install"

Brylie Christopher Oxley — Tue, 09 Apr 2019 08:18:22 +0000

Using "sudo" when installing NPM packages may put your computer at risk, by giving untrusted code administrative privileges. Please do not use "sudo" when installing NPM packages.

Instead, use the following instructions to allow NPM to install global packages without administrative privileges:

https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally

This work is licensed under a Creative Commons Attribution 4.0 International License.