
Toxic productivity is a dangerous state of being that can have serious consequences for both individuals and their loved ones. It's a trap that's easy to fall into, especially in today's fast-paced world where it often feels like there's never enough time to get everything done. But the harsh reality is that trying to be overly productive can have disastrous results.

Have you ever felt like you're working harder and longer than ever before, yet still struggling to keep up? Do you find yourself neglecting your own well-being and the well-being of those around you in the pursuit of productivity? If so, you may be dealing with toxic productivity.

What is toxic productivity? Simply put, it's when an individual becomes so focused on being productive that they begin to sacrifice their own health and happiness in the process. It's an unhealthy obsession with getting things done, no matter the cost.

There are several signs that you may be experiencing toxic productivity. These include:

1. Working long hours without taking breaks: It's important to have a healthy work schedule that includes regular breaks to rest and recharge. If you're working long hours without taking breaks, it could be a sign that you're trying to be too productive at the expense of your own well-being.
2. Neglecting self-care: Toxic productivity often leads individuals to neglect their own self-care, such as skipping meals, not getting enough sleep, and not engaging in activities that bring them joy.
3. Putting work above all else: If you're constantly prioritizing work over your personal relationships and hobbies, it could be a sign that you're struggling with toxic productivity.
4. Exhibiting perfectionist tendencies: An excessive need for perfection can lead to excessive amounts of time spent on tasks and an inability to let go of mistakes. This can be a sign of toxic productivity.
   So, what can you do to remedy toxic productivity and get back on track? It's important to prioritize self-care and work-life balance. This can include setting boundaries for work, taking breaks, and engaging in activities that bring joy and relaxation. It may also be helpful to seek the support of a therapist or coach to work through any underlying issues that may be contributing to toxic productivity.

Remember, productivity is important, but it's not worth sacrificing your own health and happiness. Take the time to care for yourself and those around you, and you'll be on your way to a healthier, more balanced life.


Overcoming Toxic Productivity: The Importance of Self-Care and Work-Life Balance


These systems have become increasingly important in recent years, as organizations seek to improve the reliability and performance of their systems by leveraging the power of multiple computers. However, building and maintaining distributed systems can also present several challenges. In this article, we will discuss some of the key concepts and challenges involved in building distributed systems.

## Key Concepts in Distributed Systems

Several key concepts are important to understand when building distributed systems. These include:

- Transparency: A distributed system should operate transparently, meaning that users should not be aware of the fact that the system is distributed across multiple computers.
- Heterogeneity: Distributed systems often involve a mix of different hardware and software platforms, which can make it challenging to ensure compatibility and interoperability.
- Scalability: Distributed systems should be able to handle an increasing workload without experiencing a decline in performance.

## Benefits and Challenges of Distributed Systems

Distributed systems can provide several benefits, including:

- Improved reliability: A distributed system can be more resilient to failures by distributing a workload across multiple computers.
- Improved performance: Distributed systems can often process a workload more quickly than a single computer, as the workload can be divided and processed in parallel. However, distributed systems also present several challenges, including:
- Communication and coordination: Ensuring that the different components of a distributed system can communicate and coordinate effectively can be a challenge.
- Handling failures and security threats: Distributed systems must be able to handle failures and security threats, such as network outages or malicious attacks.

## Types of Distributed Systems

There are several different types of distributed systems, including:

- Client-server systems: In a client-server system, clients send requests to servers, which process the requests and return the results.
- Peer-to-peer systems: In a peer-to-peer system, all computers are equal and can act as both clients and servers.
- Hybrid systems: Hybrid systems combine elements of both client-server and peer-to-peer systems.

## Architectural Models for Distributed Systems

Several different architectural models can be used to design distributed systems, including:

- Layered model: In a layered model, the system is divided into layers, with each layer responsible for a specific function.
- Event-based model: In an event-based model, the system is divided into components that communicate with each other through events.
- Object-based model: In an object-based model, the system is divided into objects that can interact with each other through methods.

## Designing for Transparency and Performance

When designing distributed systems, it is important to strike the right balance between transparency and performance. On the one hand, transparency is important as it allows users to interact with the system seamlessly. On the other hand, too much transparency can impact performance as it requires additional communication and coordination among the different components of the system. As such, it is important to carefully consider the trade-offs between transparency and performance when designing a distributed system.

## Testing and Debugging Distributed Systems

Testing and debugging distributed systems can be a complex and time-consuming process, as it involves ensuring that the different components of the system are working together correctly. It is important to thoroughly test and debug a distributed system to ensure that it is functioning as intended and to identify and fix any issues.

## Ongoing Maintenance of Distributed Systems

Distributed systems require ongoing maintenance to ensure that they continue to operate effectively and efficiently. This may involve monitoring the system to identify and fix any issues, updating the design to incorporate new features or address security vulnerabilities, and performing regular backups to protect against data loss. It is essential to have a well-defined maintenance plan in place to ensure that the system remains reliable and performs at its best.


Distributed Systems: Key Concepts and Challenges


My crappy superpower is solving difficult problems as I'm falling asleep. Doesn't sound too bad, right? Here's the catch: I always convince myself I don't need to write the solution down.

It's 1:18 AM. I just figured it out. The answer is so simple, I can't believe it took me this long. Do I blind myself opening my phone to write it down? No, I can finally sleep now! There's no way I'll forget.

It's 8:32 AM. I can't believe I've done this again.

---

I have a new policy: **write it down.** Every single time. No matter if the idea comes to me in the shower, the middle of a dream, or in a conversation.

Most of my ideas are bad. But this way I'll never miss an opportunity.


Write it down


Have you noticed that some people write extremely well? Take Aaron Swartz' article ["Believe you can change"](http://www.aaronsw.com/weblog/dweck):

> Carol Dweck was obsessed with failure.

What an _amazing_ first sentence. I'm immediately glued to this article. Who is Carol Dweck? What's wrong with her?

If I were writing that, I'd start with the immediately boring:

> Carol Dweck is a Professor of Psychology at Stanford, studying the behavior of children and how they deal with failure.

Because I have a lot of practice writing in this dull manner that meets school requirements. But I'm already bored reading it.

I'm learning to recognize good writing, and I'm fascinated. We all use the same set of words, but some writers are so much better at using them.


Good Writers


## What is unit testing ?

Unit testing involves breaking your program into pieces and subjecting each
piece into a series of tests.

Usually, tests are run as separate programs, but the method of testing varies,
depending on the language and type of software (GUI, command-line, library).
Tests are usually run periodically, often after every change to the source
code. For details check out the unit testing article in
[Wikipedia](https://en.wikipedia.org/wiki/Unit_testing).

Most languages have [unit testing
frameworks](http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks).
[`pytest`](http://pytest.org/) and
[`unittest`](https://docs.python.org/2/library/unittest.html) are two
testing frameworks used by [coala](https://coala.io).

## [`pytest`](http://pytest.org/) or [`unittest`](https://docs.python.org/3/library/unittest.html) for coala testing API ?

coala uses [`unittest`](https://docs.python.org/3/library/unittest.html)
for testing API but `pytest` has better features which are also discussed in
the issue [coala/coala#3676](https://github.com/coala/coala/issues/3676) and
over gitter channel.

For example, `pytest` fixtures:

Although unittest does allow us to have setup and teardown, pytest extends
this quite a bit. We can add specific code to run:

- at the beginning and end of a module of test code
  (setup_module/teardown_module)
- at the beginning and end of a class of test methods
  (setup_class/teardown_class)
- alternate style of the class level fixtures (setup/teardown)
- before and after a test function call (setup_function/teardown_function)
- before and after a test method call (setup_method/teardown_method)

Finally, all agreed on using `pytest` for the testing API. Thanks to
[@NiklasMM](https://github.com/NiklasMM).

## BaseTestHelper, A Base Class for All Bears' Tests

After everyone's agreement on pytest, we moved on with the pytest for creating
the base class of bear's tests. [PR #5496](https://github.com/coala/coala/pull/5496).

Now, all BearTestHelpers class will inherit from `BaseTestHelper` class.
Like,

```py
class BaseTestHelper:
    pass

class LocalBearTestHelper(BaseTestHelper):
    pass

class GlobalBearTestHelper(BaseTestHelper):
    pass
```

Go through the [cEP-0027](https://github.com/coala/cEPs/blob/master/cEP-0027.md) for more information.

## LocalBearTestHelper, A Test Helper Class for All Local Bears

coala testing API has a test helper class for simplification of testing of
local bears which supports following methods:

- `check_validity(...)` and `check_invalidity(...)`

  `check_validity` or `check_invalidity(...)` asserts if your bear yields
  any results for a particular check with a list of strings.

- `check_results(...)`

  `check_results` asserts if your bear results match the actual results on
  execution on the command line interface.

- `verify_local_bears(...)`

  `verify_local_bear` asserts that a check of the given lines with the given
  local bear either yields or does not yield any results.

## GlobalBearTestHelper, A Test Helper Class for All Global Bears

coala's testing API does not support global bear test helper till date. This
project will add support for that. Work is going on with full pace. For the
status, do check [PR #5522](https://github.com/coala/coala/pull/5522).

## What lies ahead ?

We are working on testing API by coding, testing and debugging, failing and
succeeding. Till now, the burndown chart looks like:
![GSoC 2018 Burndown-Phase I](/images/blog/burdown-phase1.png)

I’m working on the GlobalBearTestHelper testing API and I’m likely to complete
it by this week.

Thanks for stopping by ! Happy coding ! :blush:


GSoC'18 Post#2: `pytest` over `unittest`


To know about [coala](https://coala.io), go through the
[gsoc-with-coala](/blog/2018/gsoc-with-coala/) post.

## Project abstract

The aim of the project is to improve linter bears in coala by improving the
testing API that adds support for global bears, adding base test helper class,
automating the tests for bears, adding support for 7 additional linter bears
and enhancing the documentation for coala API and coala-bears.

### Project Mentors:

- [Niklas Meinzer](https://github.com/NiklasMM)
- [Ipshita Chatterjee](https://github.com/IpshitaC)
- [Abdeali Kothari](https://github.com/AbdealiJK)
- [Max Hahn](https://github.com/Mixih)

## What are Linter Bears ?

[`Linter Bears`](http://api.coala.io/en/latest/Developers/Writing_Linter_Bears.html)
word is a combination of the two terminologies: Linter and Bears.
[Linter](<https://en.wikipedia.org/wiki/Lint_(software)>) is a tool that analyses
source code to flag programming errors, bugs, stylistic errors, and suspicious
constructs. Bears in coala is meant to do some analysis on source code. It can
check your code for potential problems, calculate metrics and even provide
corrections for your code.

[Linter Bears](http://api.coala.io/en/latest/Developers/Writing_Linter_Bears.html)
are bears that are capable of wrapping third party open source linters, and to
be sustainable even allows you to write custom code analysis routines, thus
extending the modular functionality of coala. You don't have to go through the
hassle of learning how to use various tools for different programming
languages. With over 45 supported languages(and counting), things get much
simpler under a single roof.

## Community Bonding Period

The Milestones of my Project during Community Bonding Period are:

- Get in touch with the mentors via [Google Hangouts](https://hangouts.google.com/)
  and [Gitter room](https://gitter.im).
- Make a [coala Enhancement Proposal(cEP)](https://github.com/coala/cEPs/pull/149)
  of coala's Bears Testing API and get it merged.
- Get assigned to all the issues of the project and finalise tasks to be
  implemented in Coding Phase-I.

## Conclusion

On 14<sup>th</sup> May, the community bonding has come to an end and I've
nearly managed to complete my milestone. My earlier contributions to coala
helped me to get knowledge about the [`linter` class](http://api.coala.io/en/latest/coalib.bearlib.abstractions.html#module-coalib.bearlib.abstractions.Linter)
of coala. It has been a wonderful time so far. I've managed to get
[cEP-0027](https://github.com/coala/cEPs/blob/master/cEP-0027.md) merged.

Thats all for community bonding !
Stay tuned ! Till then, Happy Coding !


GSoC'18 Post#1: Community bonding ends


## What’s GSoC ?

GSoC is an annual program administered and funded by Google for students all
around the world to contribute to open source software in summer. You may
think that only undergrads are allowed to take part in this program, but
that’s not the case. Undergrads, students in graduate programs, PhD candidates
can take part in GSoC. As computer science or software engineering students
GSoC one of the most prestigious things that students can accomplish.

## Why open source ?

Open source software is the heart and soul of many organizations. It would be
real hard to imagine more secure and reliable software without open source
initiatives. Everyday hundreds and thousands of developers contribute to
different open source software. Just to get an idea about how OSS contributes
for entire software development industry, here’s a look at the statistics on
different project on GitHub in 2017.

> To celebrate your contributions and a spectacular year together, let’s look
> back at the projects, people, and teams of 2017.
>
> > [https://octoverse.github.com](https://octoverse.github.com)

---

## GSoC 2018

![GSoC 2018 Project](/images/blog/GSoCPage.png)

> via GSoC 2018 projects page

GSoC is based on a model of different organizations providing projects for
students all around the world. Each organization assign mentors for every
project and students are paired with mentors once they get selected.

I’m happy that I have been selected to work with [coala](https://coala.io) for
[GSoC 2018](https://summerofcode.withgoogle.com/).

![Sangam](/images/blog/selection.png)

## About coala

[coala](https://coala.io) is a free and open-source language independent code
analysis tool, written in Python. The primary goal of coala is to make it
easier for developers to create [rules and standards](https://docs.coala.io/en/latest/Users/coafile.html)
to be followed in the source code.

coala provides a unified command-line interface for linting and fixing all
your code, regardless of the programming languages you use. coala allows you
to simply check your code against certain quality requirements. The checking
routines are named Bears in coala. You can easily define a simple project file
to check your project with all bears either shipped with coala or ones you
found in the internet and trust.

You can use coala from within your favorite editor, integrate it with your CI,
get the results as JSON, or customize it to your needs with its flexible
configuration syntax.

## What more ?

This is my first blog post about GSoC, many more will follow. Here I will post
about the progress of my project along with some random posts about life or
some tech tutorial. There are two reasons why I have started this blog. First
I have been selected in GSoC and the program require writing blog. Secondly,
I follow lots of blogs on various topics on Quora/Medium etc regularly so I
always thought about writing a blog but never started one. So after my
selection in GSoC, I started blogging with this one.

It is going to be a challenging task for sure. Hoping to have lots of fun and
looking forward to learning many new things this summer with coala and plan to
use this blog to post updates and developments. Feel free to contact me for
any queries/questions regarding GSoC and I’ll be more than happy to answer
them.

Thats all folks ! Stay tuned.


GSoC 2018 with coala


## End-term Report, KWoC

### [Introduction](#intro)

Kharagpur Winter of Code is a 5-week long online programme for the students
of various colleges, who are new to open source software development. The
programme helps students to get involved in open source and prepares them
for many open source summer programmes like Google Summer of Code.

Hi, Myself [Sangam Kumar](https://www.sangam.dev). My GitHub ID is
[sangamcse](https://github.com/sangamcse). I came to know about the programme
in an Open Source Workshop during Abhiyantran, NIT Sikkim 2017. I registered
for it on 20th Nov 2017 and started choosing a project. My semester exam ended
on 22nd Nov 2017 so I was free to start coding.

### Choosing a Project

After registration, next step was to find a suitable project from the
[listed projects](http://kwoc.kossiitkgp.in/projects).

I found [Coala](https://github.com/coala/) very interesting for me. It provides
a unified interface for linting and fixing code with a single configuration
file, regardless of the programming languages used. I joined the gitter
communication channel of coala and read the newcomer guidelines. My mentor for
this project is [Yash Nisar](https://github.com/yash-nisar). I contacted him
personally via [Facebook](https://www.facebook.com/yash.nisar/). He guided me
to take all the steps to start. I started contributing after all the steps
done.

### Commiting on Github

#### _[My First PR](#firstpr)_

To start contribution on Coala, there were some rules to follow. It was all
given in the newcomer guidelines. Next step was to find a
[difficulty/newcomer issue](https://github.com/coala/coala-bears/issues?q=is%3Aopen+is%3Aissue+label%3Adifficulty%2Fnewcomer).
I chose an [issue](https://github.com/coala/coala-bears/issues/2004) which was
opened by my mentor. The issue was very easy for me. I solved the issue and
sent [the PR](https://github.com/coala/coala-bears/pull/2148). But let me tell
you that getting merged the PR was not so easy.

![First changes for the issue](/images/blog/1.png)

Changes required in the issue was not this much. So
[Yash Nisar](https://github.com/yash-nisar 'Yash Nisar') told me to make some
more changes in another file. So my final change looks like this.

![Second changes for the issue](/images/blog/2.png)

And there was some more issue in the PR. There was a failing test case on
circleCI but it was something related to an inability to fetch some dependency.
The gitmate-bot was checking the commit and my commit was not proper, so
[Yash Nisar](https://github.com/yash-nisar 'Yash Nisar') helped me in that.

![Suggestion by mentor](/images/blog/3.png)

I made some changes in my commit which now look like below.

![Changes in commit as suggested](/images/blog/4.png)

And it passed all test cases for my first PR. It was ready to merge but
maintainer was taking some time to merge it. So the mentor suggested to
rebase my branch.

![Suggestion by mentor](/images/blog/5.png)

On 24th Dec, finally, my first PR got merged into the master branch of
coala/coala-bear.

![Merged PR](/images/blog/6.png)

#### _[My Second PR](#secondpr)_

Before choosing my second issue, I reviewed 2/3 difficulty/newcomer PRs. I was
continuous active on gitter channel of coala. Then I searched for a
[difficulty/low issue](https://github.com/coala/coala-bears/issues?q=is%3Aopen+is%3Aissue+label%3Adifficulty%2Flow).

However, I chose a needs-design [issue](https://github.com/coala/landing-frontend/issues/250).
This issue requires changes in the [coala.io/#/languages](https://coala.io/#/languages)
page where in place of programming language's name, there should be programming
language's logo.

I have sent a [PR](https://github.com/coala/coalaCSS/pull/29) which is some
changes in CSS.

![Changes in Second PR](/images/blog/7.png)

This PR still needs approval. I am working on a script to fetch the logo
from wikidata and add that logo to the issue. [@jayvdb](https://github.com/jayvdb),
who is one of the owners of coala, is helping me in that script. That script
needs [pywikidata API](https://pywikidata.readthedocs.io/en/latest/chapter2.html#fetching-items).

### Post KWoC

- KWoC is ending now but since it’s an open source project, I could contribute to
  it anytime. I’ve planned to fix the issues on coala issue's list.

- I've planned to contribute to some other open-source, too.

Finally, I would like to thanks my mentor [Yash Nisar](https://github.com/yash-nisar)
for helping me. I hope he will be there when I need his mentorship.
A Lot more to learn from you. Thanks again!🙂 Also, thank you
[Kharagpur Open Source Society(KOSS)](https://kossiitkgp.in/) and the people
at KOSS for organizing Kharagpur Winter of Code and making sure that every
student who is new to the open source get benefited.

**[Sangam Kumar](https://github.com/sangamcse)**


Blog