Category: Tech

Everything Intresting in Tech

  • Basic tech

    Table of Contents

    Videos

    Links

    https://ascii.co.uk/art

  • Learning Resources in Tech

    Useful links worth a mention:

    Coding https://reeborg.ca/reeborg.html?lang=en&mode=python&menu=worlds%2Fmenus%2Freeborg_intro_en.json&name=Alone&url=worlds%2Ftutorial_en%2Falone.json

  • When Tech Goes Wrong: Lessons from the Front Lines

    In our rapidly evolving digital age, technology plays a pivotal role in shaping our daily lives and the fabric of society at large. From enhancing connectivity to revolutionizing industries, the benefits of technological advancement are immense. However, the path of progress is not without its pitfalls. As we push the boundaries of innovation, instances where technology goes awry serve as stark reminders of the importance of responsibility, oversight, and ethical considerations in development and deployment. This blog delves into five detailed real-life case studies where technology failed, examining the lessons learned from each.

    1. The Boeing 737 MAX Tragedy

    The Incident: The Boeing 737 MAX, a symbol of modern aviation technology, was involved in two catastrophic crashes within five months—Lion Air Flight 610 in October 2018 and Ethiopian Airlines Flight 302 in March 2019. The root cause was identified as a flawed flight control system (MCAS) that erroneously activated based on incorrect sensor readings, forcing the planes into unrecoverable nose-dives.

    Lessons Learned: The tragedy underscored the critical importance of comprehensive testing and validation of automated systems in safety-critical applications. It also highlighted the need for transparency and integrity in reporting and addressing potential safety issues. Boeing’s response led to a global grounding of the fleet, a redesign of the flight control system, and a reevaluation of regulatory oversight processes.

    2. The 2010 Flash Crash

    The Incident: On May 6, 2010, the U.S. stock market experienced a trillion-dollar stock market crash, which saw the Dow Jones Industrial Average plummet nearly 1,000 points in minutes before rapidly recovering. The cause was largely attributed to high-frequency trading algorithms reacting to each other in unpredictable ways, creating a feedback loop of selling.

    Lessons Learned: This event brought to light the vulnerabilities inherent in automated trading systems and the potential for unforeseen interactions between algorithms to destabilize financial markets. It led to regulatory changes aimed at preventing such incidents, including the introduction of circuit breakers to temporarily halt trading in response to extreme market volatility.

    3. The Heartbleed Bug

    The Incident: Discovered in 2014, the Heartbleed bug was a serious vulnerability in the OpenSSL cryptographic software library. This flaw allowed attackers to read sensitive information from affected servers, compromising the security of millions of websites and exposing user data to potential theft.

    Lessons Learned: Heartbleed highlighted the dangers of reliance on open-source software without adequate support or resources for thorough security auditing. It prompted a significant increase in investment in open-source security projects, a reevaluation of security practices by organizations worldwide, and the importance of regular, comprehensive vulnerability assessments.

    4. The Toyota Unintended Acceleration Case

    The Incident: Between 2009 and 2011, Toyota was forced to recall millions of vehicles due to reports of unintended acceleration. Investigations pointed to a mix of potential mechanical, electronic, and software issues, including problematic floor mats and sticky accelerator pedals, as well as questions about the electronic throttle control system.

    Lessons Learned: The Toyota case study stressed the importance of considering the complex interplay between software, hardware, and human factors in product design. It led to increased scrutiny of automotive software systems, the implementation of more rigorous safety standards, and the adoption of fail-safes and redundancy in vehicle control systems.

    5. The 2017 Equifax Data Breach

    The Incident: In 2017, Equifax, one of the largest credit reporting agencies, suffered a massive data breach exposing the personal information of approximately 147 million people. The breach was attributed to the exploitation of a known vulnerability in a web application framework that Equifax had failed to patch in time.

    Lessons Learned: The Equifax breach served as a wake-up call about the critical importance of cybersecurity vigilance, the need for timely application of security patches, and the dangers of complacency in protecting sensitive data. It also underscored the need for robust incident response plans and the importance of transparency with affected parties in the wake of a data breach.

    Conclusion

    These case studies serve as powerful lessons in the risks associated with technological advancement and the imperative of ethical stewardship in the tech industry. They remind us of the importance of rigorous testing, the potential consequences of oversight, and the ongoing need for balance between innovation and safety. As we continue to navigate the digital age, let these lessons guide us toward more responsible and resilient technological developmen

  • Pytest

    Testing

    Testing is an essential part of software development that ensures your code works as expected and helps maintain its reliability over time.

    Pytest is a powerful, no-boilerplate-needed testing framework in Python that makes writing simple and scalable test cases easy. Let’s explore how you can leverage Pytest in your Python projects.

    Why Pytest?

    Pytest is a popular testing framework for Python due to its simplicity and flexibility. It supports powerful fixtures, has a rich plugin architecture, and can easily integrate with other testing tools and frameworks.

    With Pytest, writing tests becomes more pythonic and less cumbersome compared to other frameworks like unittest.

    Setting Up Pytest

    First, you need to install Pytest. Simply run:

    pip install pytest

    After installation, you can start writing your test cases.

    Example Project Structure

    Imagine you have a simple Python project with the following structure:

    • my_project/
      • app.py
      • tests/
        • test_app.py

    In app.py, you have a function you want to test. For instance:

    # app.py

def add_numbers(a, b):
    """Add two numbers."""
    return a + b

    Writing Your First Test

    Now, let’s write a test for the add_numbers function in test_app.py.

    # tests/test_app.py

from app import add_numbers

def test_add_numbers():
    assert add_numbers(2, 3) == 5

    This test checks if the add_numbers function correctly adds two numbers.

    Running the Tests

    To run your tests, simply execute:

    pytest

    Pytest will automatically discover and run all tests in the tests directory.

    Parametrizing Tests

    One of the powerful features of Pytest is parameterized tests. This allows you to run the same test function with different inputs. For example:

    # tests/test_app.py

import pytest
from app import add_numbers

@pytest.mark.parametrize("a, b, expected", [(2, 3, 5), (4, 5, 9), (0, 0, 0)])
def test_add_numbers_parametrized(a, b, expected):
    assert add_numbers(a, b) == expected

    This will run test_add_numbers_parametrized three times with different sets of arguments.

    Handling Exceptions

    Testing exceptions is straightforward with Pytest. Suppose you have a function that raises an exception:

    # app.py

def divide_numbers(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

    You can write a test to ensure the exception is raised correctly:

    # tests/test_app.py

import pytest
from app import divide_numbers

def test_divide_numbers_exception():
    with pytest.raises(ValueError):
        divide_numbers(10, 0)

    Conclusion

    Testing with Pytest is a vital part of the Python development process. It’s straightforward, flexible, and powerful. By integrating testing into your workflow, you can write more reliable and maintainable code. Remember, a well-tested application is a robust application!

    Other Reading

    4 Techniques for Testing Python Command-Line (CLI) Apps – Real Python

    Get Started — pytest documentation

    Pytest – Starting With Basic Test

    Testing Python Applications with Pytest – Semaphore Tutorial

  • Navigating the Tech World with the ‘7 Why’s’: Insights from Outliers and the Power of Intention

    Introduction

    In the tech industry, where innovation and complexity meet, finding your ‘why’ is not just insightful, it’s crucial for success. This concept becomes even more powerful when intertwined with Malcolm Gladwell’s insights from “Outliers,” particularly his observation about plane crashes resulting from seven consecutive human errors. In this article, we delve into how the ‘7 Whys’ technique, combined with a deliberate and intentional approach, can be transformative for tech professionals.

    The Importance of “Why” in Tech:

    The relentless pace of the tech world demands more than just technical skills; it requires clarity of purpose and direction. Gladwell’s analysis of errors leading to aviation disasters is a poignant reminder of how a lack of clarity can lead to cumulative missteps in technology projects and careers.

    The 7 Why’s Technique

    Originally used in manufacturing to identify root causes, the ‘7 Whys’ is a method of iterative questioning that helps uncover deeper motivations. It aligns perfectly with Gladwell’s concept of compounded errors, highlighting the need to understand the underlying reasons behind our professional actions to avoid potential pitfalls.

    Finding your Why

    Being Deliberate and Intentional

    In tech, every decision and action should be deliberate and intentional. This approach is not just about making choices; it’s about understanding the reasons behind these choices.

    Being deliberate means being aware of the implications of your actions, just as understanding the consecutive errors in a plane crash helps in preventing them. Being intentional is about aligning your actions with your deeper purpose – your ‘why’. This section can explore how a deliberate and intentional approach, combined with the ‘7 Whys’, can lead to more meaningful and impactful work in tech.

    Applying the 7 Whys in Tech

    Consider your engagement in a tech project. Asking ‘Why am I working on this?’ might initially yield a surface-level answer. But as you continue to question, seeking deeper understanding, you might uncover motivations like a desire to innovate for social good or bridge digital divides, leading to more focused and intentional work.

    Conclusion

    In the dynamic world of technology, understanding your ‘why’ and acting deliberately and intentionally can be your guiding stars. The ‘7 Whys’, especially when considered alongside the insights from “Outliers”, offers a path to self-discovery and purpose-driven work.

    As you evolve in your tech career, continually revisiting your ‘why’ and the intent behind your actions will keep you aligned and prevent the ‘crashes’ of professional misdirection.